Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997

home *** CD-ROM | disk | FTP | other *** search

/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / m / musik / notedita / quelltxt.lst < prev next >

Wrap

File List | 1996-11-17 | 347.2 KB | 5,911 lines

' Prg zum Schreiben kurzer Notenstücke für c-Flöte allein | 'NOTEDITA.GFA' V.1.0 ' ############################################################################## ON ERROR GOSUB a_fehler_abfangen !_: * Stückanz.: 160 pro Diskette @0_globalvariablen !_: * Textlänge: 200 Noten=1Bldsch. @0_programmbild_malen !_: * Tonlängen: 1/4,1/8,1/16,1/32 @0_hauptfile_laden !_: * Tonumfang: c1...c3/einstimmig @0_midi_vorbereiten !_: * Keyboard.: Casio MT-260(opt.) @0_hauptschleife !_: * P.sprache: GFA-BASIC 3.07 D ' ############################################################################## ' V o r b e r e i t u n g e n : ' ############################################################################## > PROCEDURE 0_globalvariablen !_: ' ---------------------------------------------------------------------------- ' Lokalvariablen für diese Prozedur: ' ---------------------------------------------------------------------------- LOCAL j| ! Zählvariable LOCAL i| ! Zählvariable LOCAL z| ! Zählvariable LOCAL lz| ! Notenlinienzwischenraumanzahl pro Notenzeile LOCAL i% ! Zählvariable LOCAL r% ! Druckerparameter dezimal LOCAL a$ ! Druckerparameter binär ' ---------------------------------------------------------------------------- ' D r u c k e r a n p a s s u n g : ' ---------------------------------------------------------------------------- LET r%=XBIOS(33,-1) ! Druckparameter lesen ' PRINT a$ ! test LET a$=BIN$(r%) ! Binär MID$(a$,LEN(a$)-2)="1"! 960 Punkte setzen : GFA-Handbuch: 12 - 25 LET r%=VAL("&X"+a$) ! Dezimal LET r%=XBIOS(33,r%) ! Parameter setzen ' LET r%=XBIOS(33,-1) ! Parameter lesen / test ' LET a$=BIN$(r%) ! test ' PRINT a$ ! test ' ---------------------------------------------------------------------------- ' K o n s t a n t e n : ' ---------------------------------------------------------------------------- ' ! B i l d s c h i r m a b m e s s u n g e n : LET g_bb%=640 ! Bildschirmbreite LET g_bh%=400 ! Bildschirmhöhe ' ! N o t e n r e c h t e c k : LET g_nb|=16 ! Notenrechteckbreite ' ! M e n ü v a r i a b l e : LET g_mh|=35 ! Menühöhe (da bei Null angefangen, geht das Menü bis ' ! einschließlich: g_mh|-1, d.h. die oberste Notenzeile ' ! fängt an bei einschließlich y=g_mh|. Bitte so ' ! wählen, daß g_nzlh|(Notenzeilenhöhe) ganze Zahl wird ! ' ! N o t e n z e i l e : LET g_za|=5 ! Anzahl der Notenzeilen: so wählen, daß ' ! g_nzlh| eine ganze Zahl wird: LET g_nzlh|=(g_bh%-g_mh|)/g_za| ! Notenzeilenhöhe berechnen: (Bildschirmhöhe ' ! -Menühöhe)/Anzahl der Notenzeilen LET lz|=11 ! Notenlinienzwischenraumanzahl pro Notenzeile: ' ! 5 Hauptnotenlinien = [4] Zwischenräume + ' ! 1 untere Linie + Randabstand = 1 + 2 = [3] ' ! 2 obere Linien + Randabstand = 2 + 2 = [4] LET g_la|=g_nzlh|/lz| ! Abstand zwischen zwei Notenlinien berechnen: ' ! Zeilenhöhe / Linienzwischenraumanzahl pro Notenzeile ' ! Dieser Notenlinienabstand ist eigentlich eins weniger, ' ! weil eine Notenliniendicke (=1) miteinberechnet wurde. ' ! Die Zahl muß durch 2 teilbar sein,wegen '2_noten_foto' ' ! O b e r e N o t e n a n z a h l s c h r a n k e : LET g_npz|=g_bb%/(g_nb|) ! Anzahl der Noten pro Zeile berechnen: ' ! Bildschirmbreite / Notenbreite+Notenabstand LET g_os%=g_za|*g_npz|! obere Schranke aller Noten berechnen: ' ! Notenzeilenanzahl * Zeilenanzahl ' ! T o n h ö h e n - & P e r i o d e n a n z a h l : LET g_tha|=25 ! Tonhöhenanzahl=Tontastenanzahl: c1 - c3 LET g_tpa|=3 ! Tonperiodenanzahl,beginne mit 0: 1/4, 1/8, 1/16, 1/32 ' ! K l a v i a t u r t a s t e n b r e i t e : LET g_ntb|=24 ! Notentastenbreite LET g_ptb|=20 ! Pausentastenbreite ' ! S o u n d p a r a m e t e r : LET g_vz|=24 ! Verzögerungswert: muß durch 2^g_tpa| teilbar sein LET g_okt|=4 ! Startoktave (bei 4 Oktaven ist das die 3.von unten) ' ! für Sound-Befehl (also nicht für MIDI) LET g_ls|=12 ! Lautstärke (1-12 [+3=15,1.Note im Takt]) LET g_sp%=40 ! Pause zwischen den Stücken für's Abspielen ' ! S t ü c k a n z a h l : LET g_stka|=160 ! 8*20 Stücke können in den Ram-Speicher geladen werden. ' ! C u r s o r s t r i n g : LET g_cs$="" ! Völlig leerer Notenbereich, auch ohne Notenlinien ' ! L e e r z e i c h e n n e g a t i v : LET g_lz$="" ! Da kommt einfach ein Stück leere Notenzeile rein ' ! L ö s c h n o t e : LET g_ln$="" ! Da kommt ein Stück Notenzeile ohne Note rein ' ! N o t e n s c h l ü s s e l : LET g_ns$="" ! Da kommt der Notenschlüssel rein ' ! P r o g r a m m n a m e : LET g_prgname$="" ! Bildspeicher für Programmname ' ! D a t e i n a m e n : LET g_fn$="A\:.NTA" ! der Stückname des aktuell bearbeiteten Stücks LET g_hf$="HAUPTFLE.NTN" ! vorläufiger Name für die Hauptdatei ' ! K l a v i a t u r : LET g_kl$="" ! Die Klaviatur soll fotografiert werden weg. Infotexte ' ! L e e r b i l d s c h i r m : LET g_lb$="" ! Der ganze Bildschirm ohne Noten soll fotografiert wer. ' ! H e l p t a s t e n t e x t b i l d s c h i r m : LET g_hp$="" ! Helptastenbildschirm speichern ' ! F i l e s e l e c t b o x : LET g_fsb$="" ! Fileselectbox wird fotografiert werden ' ! T e s t : LET g_proctest$="" ! Name der aufrufenden Prozedur fürDebugging ' ! B l o c k v a r i a b l e n : LET g_bla%=0 ! Blockanfang LET g_ble%=0 ! Blockende ' ! M i d i : LET g_k1|=10 ! Elec.-Piano-Sound auf Kanal 1 LET g_k2|=18 ! Synth.-Ens-Sound auf Kanal 2 LET g_k3|=9 ! Percussion-Sound auf Kanal 3 LET g_perc|=0 ! Schlagzeugwahl ' ---------------------------------------------------------------------------- ' L a u f v a r i a b l e n : ' ---------------------------------------------------------------------------- LET g_w!=FALSE ! =-1: Statt normalem Hauptfile anderes laden LET g_midi!=FALSE ! =-1: Midi-Keyboard angeschlossen ' ! N o t e n n u m m e r n : LET g_mt|=0 ! Merker für alte Tonhöhe( siehe Procedrue'a2_s') LET g_n%=1 ! aktuelle Notennummer=Cursorposition LET g_mn%=0 ! bisherige, maximale Notennummer LET gu_mn%=0 ! maximale notennummer bei Undostück LET g_t%=1 ! 0=1/4, 1=1/8, 2=1/16, 3=1/32 ' ---------------------------------------------------------------------------- ' A r r a y s : ' ---------------------------------------------------------------------------- ' ! F r e q u e n z - A r r a y : DIM fr%(25*2) ! Frequenzen aller 25 Tasten einschließlich Vierteltöne RESTORE frequenzen ! Read-Zeiger auf Frequenzdatei FOR i|=1 TO 25*2 ! d READ fr%(i|) ! Frequenz einlesen NEXT i| ! d ' ! S t u e c k e - A r r a y : DIM g_stueck$(g_stka|+1)! Hier stehen alle Stücke drin, die derzeit bearbeitet ' ! werden können. ' ! 0.Stelle Inhvz., 1. Stelle Datum, deshalb 161 statt159 ' ! B o o l - F e l d f ü r H a u p t m e n ü : DIM g_zs!(2,5) ! Dimensionierung Bool-Feld: Zeilen 1-2 , Spalten a-e ' ............................................................................ ' ! N o t e n s p e i c h e r : DIM g_n$(g_os%+1) ! Notenspeicher g_n$(g_n%) ist String mit den Stellen: ' ! 1.) Tonhöhe (a-y) c1=a, c3=y, Pause=z ' ! 2.) Periodendauerkennziffer (0-3): ' 0=1/4, 1=1/8, 2=1/16, 3=1/32 ' ! 3.) Gebunden mit Vorgängernote ? (Ja=1,Nein=0) ' ! 4.) Betonte Note ? (Ja=1,Nein=0) DIM gu_n$(g_os%+1) ! Undostück-Array identisch mit g_n$()-Array vor letz- ' ! tem Befehl. ' ............................................................................ ' ! N o t e n b i l d s p e i c h e r : DIM g_nb$(g_tha|+1,g_tpa|,1,1) ! Notenbildspeicherarray, die Argumente sind: ' ! 1.) Tonhöhe (1-26) c1=1, c3=25, Pause=26 ' ! 2.) Periodendauerkennziffer (0-3) ' 0=1/4, 1=1/8, 2=1/16, 3=1/32 ' ! 3.) Gebunden mit Vorgängernote ? (Ja=1,Nein=0) ' ! 4.) Betonte Note ? (Ja=1,Nein=0) ' Dieser Array wird in der Prozedur '2_noten_foto(,)' gefüllt ' ............................................................................ ' ! S t a r t k o o r d i n a t e n : ' ! (links oben) eines Notenrechtecks: DIM g_x%(g_os%+1) ! x-Startkoordinatenarray (über maximale Notenanzahl) DIM g_y%(g_os%+1) ! y-Startkoordinatenarray (über maximale Notenanzahl) ' ............................................................................ FOR i%=1 TO g_os% ! Alle Notennummern=Notenpositionen durch: ' .......................................................................... INC j| ! Zähler für Notenspalte um eins erhöhen ' .......................................................................... LET g_x%(i%)=(j|-1)*g_nb| ! x-Startk. für Note i% berechn.: ' ! (Sp.zähler-1)*Notenbreite LET g_y%(i%)=g_mh|+z|*g_nzlh| ! y-Startk. für Note i% berechn.: ' ! (y-Start der 1.Notenzeile + ' ! Notenzeile * Notenzeilenhöhe) ' BOX g_x%(i%),g_y%(i%),g_x%(i%)+g_nb|,g_y%(i%)+g_nzlh| ! Testbild ' .......................................................................... IF j|=g_npz| ! F rechts angelangt, also Zeile zu ende: LET j|=0 ! Zähler für Notenspalte null INC z| ! Zähler für Notenzeile um eins erhöhen ENDIF ! EF rechts angelangt ' .......................................................................... NEXT i% ! Nächste Notennummer=Notenposition ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_programmbild_malen !_: ' ---------------------------------------------------------------------------- LOCAL w$ ! Tastaturspeicher ' ............................................................................ @1_helptaste ! Text einlesen für Drücken der Help-Taste GET g_x%(1),g_y%(1),g_x%(1)+g_nb|-1,g_y%(1)+g_nzlh|-2,g_cs$ ! Cursorstr.fotogr @1_notenschluessel ! d @1_programmname ! d PRINT AT(5,17);"Startvorbereitungen für ";CHR$(27);CHR$(112);" N O T E D I T A ";CHR$(27);CHR$(113);" Bitte warten... " @1_notenbild_array ! Dort werden die Noten gemalt und dann photographiert @1_notenlinien ! d @1_begrenzungslinien ! zw 2 Notenzeilen, jeweils 1 über y-Startpunkt v. Zle @1_klaviatur ! d GET g_x%(1),g_y%(1),g_x%(1)+g_nb|-1,g_y%(1)+g_nzlh|-2,g_ln$ ! Löschnote fotogr GET g_x%(1),g_y%(1),g_x%(1)+g_nb|-1,g_y%(1)+g_nzlh|-2,g_lz$ ! Leerz. fotogr. SGET g_lb$ ! Den ganzen Leerbildschirm fotografieren PRINT AT(5,17);"Startvorbereitungen für ";CHR$(27);CHR$(112);" N O T E D I T A ";CHR$(27);CHR$(113);" Bitte warten... " GET 0,0,g_bb%-1,g_mh|-1,g_kl$ ! Klaviatur fotografieren PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein LET w$=INKEY$ ! F was von der Tastatur anliegt: IF w$=" " ! F Wahlmöglichkeit für Hauptfile erwünscht: LET g_w!=TRUE ! Flag für freie Wahl des Hauptfiles setzten ENDIF ! d ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 1_helptaste !_: ' ---------------------------------------------------------------------------- LOCAL a$ ! Lesestring ' ............................................................................ CLS ! Bildschirm löschen RESTORE helptext ! Zeiger setzen READ a$ ! Zeile einlesen REPEAT ! Leseschleife LET a$=a$ ! linker Rand von 0 Spalten PRINT a$; ! Zeile auf Bildschirm IF LEN(a$)<80 AND NOT LEFT$(a$,7)=" Zurück" ! F bis nicht bis zum r. Rand : PRINT ! LF ENDIF ! d READ a$ ! Zeile einlesen UNTIL a$="**" ! Ende ' GET 0,0,g_bb%-1,g_bh%-1,a$ ! Bildschirm retten ' PUT 0,0,a$,8 ! Bildschirm invertieren SGET g_hp$ ! Helptastenbildschirm speichern CLS ! Bildschirm sauber machen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_notenschluessel !_: ' ---------------------------------------------------------------------------- LOCAL x% ! x-Koordinate vom aktuellen Punkt LOCAL y% ! y-Koordinate vom aktuellen Punkt LOCAL x% ! x-Koordinate vom alten Punkt LOCAL y% ! y-Koordinate vom alten Punkt ' ............................................................................ RESTORE notenschluessel ! Read-Zeiger auf Notenschlüssel-daten REPEAT ! Leseschleife READ x%,y% ! Koordinaten für aktuellen Punkt einlesen IF mx%<>0 AND x%<>-1 ! f alter Punkt nicht 0 und neuer nicht letzter: LINE mx%,my%,x%,y% ! vom alten zum aktuellen Punkt Linie zeichnen ENDIF ! d LET mx%=x% ! aktuellen Punkt merken LET my%=y% ! d UNTIL x%=-1 ! raus f Koordinate= -1 ' ............................................................................ ' ! Notenschlüssel fotografieren: GET g_x%(51),g_y%(51),g_x%(51)+2*g_nb|-1,g_y%(51)+g_nzlh|-2,g_ns$ CLS ! Bildschirm löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_programmname !_: ' ---------------------------------------------------------------------------- LOCAL x% ! x-Koordinate vom aktuellen Punkt LOCAL y% ! y-Koordinate vom aktuellen Punkt LOCAL x% ! x-Koordinate vom alten Punkt LOCAL y% ! y-Koordinate vom alten Punkt ' ............................................................................ RESTORE programmname ! Read-Zeiger auf Programmname-daten REPEAT ! Leseschleife READ x%,y% ! Koordinaten für aktuellen Punkt einlesen IF mx%<>0 AND x%<>-1 ! f alter Punkt nicht 0 und neuer nicht letzter: LINE mx%,my%,x%,y%-2 ! vom alten zum aktuellen Punkt Linie zeichnen ENDIF ! d LET mx%=x% ! aktuellen Punkt merken LET my%=y% ! d UNTIL x%=-1 ! raus f Koordinate= -1 ' ............................................................................ ' ! Programmnamen fotografieren: GET 56*8,0,80*8-1,16,g_prgname$! d PUT 56*8+4,0,g_prgname$,7 ! Schatten GET 56*8,0,80*8-1,16,g_prgname$! d CLS ! Bildschirm löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_notenbild_array !_: ' ---------------------------------------------------------------------------- LOCAL z| ! Periodenzähler LOCAL p| ! Positionszähler LOCAL hua| ! Noten-mit-Hals-unten-Anzahl, also c1-a LOCAL hoa| ! Noten-mit-Hals-oben-Anzahl, also h-c3 LOCAL ka| ! Kombinationenanzahl der Noten ohne Fähnch. od. Hilfsl. LOCAL mg_n% ! Merker für Notennummer ' ............................................................................ LET hua|=9 ! Noten-mit-Hals-unten-Anzahl LET hoa|=6 ! Noten-mit-Hals-oben-Anzahl LET ka|=16 ! Kombinationenanzahl der Noten ohne Fähnch. od. Hilfsl. LET mg_n%=g_n% ! Merker für Notennummer ' ............................................................................ @2_noten_malen ! Noten malen ohne Fähnchen und ohne Hilfslinien ' ............................................................................ FOR z|=0 TO g_tpa| ! Alle Tonperioden durch (TonPeriodenAnzahl): ' ! Man kann hier auch Fähnchenanzahl dazu sagen. LET w$=INKEY$ ! F was von der Tastatur anliegt: IF w$="w" OR w$="W" ! F Wahlmöglichkeit für Hauptfile erwünscht: LET g_w!=TRUE ! Flag für freie Wahl des Hauptfiles setzten ENDIF ! d ' .......................................................................... FOR g_n%=1 TO ka|/2 ! Alle Komb ohne Fähnch. od. Hilfsli: Hals unten @3_faehnchen(z|,0) ! z| Fähnchen zeichnen, 0=Hals nach unten NEXT g_n% ! Nächste Note mit nächster Kombination FOR p|=1 TO hua| ! Alle Notenpositionen mit Hals nach unten durch @2_noten_foto(0,p|,z|) ! d 0=Hals unten, p|=Position für Negativ NEXT p| ! Nächste Notenposition mit Hals nach unten ' .......................................................................... FOR g_n%=ka|/2+1 TO ka| ! Alle Komb ohne Fähnch. od. Hilfsli: Hals oben @3_faehnchen(z|,1) ! z| Fähnchen zeichnen, 1=Hals nach oben NEXT g_n% ! Nächste Note mit nächster Kombination FOR p|=1 TO hoa| ! Alle Notenpositionen mit Hals nach oben durch @2_noten_foto(1,p|,z|) ! d 1=Hals oben, p|=Position für Negativ NEXT p| ! Nächste Notenposition mit Hals nach oben ' .......................................................................... LET g_n%=ka|+1 ! Cursorposition auf Pause @3_faehnchen(z|,1) ! z| Fähnchen zeichnen, 1=Hals nach oben ' .......................................................................... LET g_n%=ka|+2 ! Cursorposition auf Pause @3_faehnchen(z|,1) ! z| Fähnchen zeichnen, 1=Hals nach oben @3_taktstrich ! Taktstrich @2_pausen_foto(ka|+1,z|) ! Pause fotografieren ' .......................................................................... NEXT z| ! Nächste Tonperiode CLS ! Noten wieder löschen, Bildschirm also leer LET g_n%=mg_n% ! Notennr.wiederherstellen mit Merker für Notenr ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_noten_malen !_: ' ---------------------------------------------------------------------------- LOCAL h| ! Zustandszähler: Notenhals unten=0 & Notenhals oben=1 ' ............................................................................ LET g_n%=0 ! Notenposition null setzen ' ............................................................................ FOR h|=0 TO 1 ! Notenhals unten: Übergabe=0, oben: Übergabe=1 ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals @3_gebundenzeichen(h|)! Gebundenzeichen ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals ' @3_betonung(h|) ! Betonungszeichen @3_taktstrich ! Taktstrich ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals ' @3_betonung(h|) ! Betonungszeichen @3_taktstrich ! Taktstrich @3_gebundenzeichen(h|)! Gebundenzeichen ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals @3_kreuz(h|) ! Erhöhungszeichen=Kreuz ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals @3_kreuz(h|) ! Erhöhungszeichen=Kreuz @3_gebundenzeichen(h|)! Gebundenzeichen ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals @3_kreuz(h|) ! Erhöhungszeichen=Kreuz ' @3_betonung(h|) ! Betonungszeichen @3_taktstrich ! Taktstrich ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenkopf(h|) ! Notenkopf @3_notenhals(h|) ! Notenhals @3_kreuz(h|) ! Erhöhungszeichen=Kreuz ' @3_betonung(h|) ! Betonungszeichen @3_taktstrich ! Taktstrich @3_gebundenzeichen(h|)! Gebundenzeichen ' .......................................................................... NEXT h| ! Notenhals oben ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenhals(1) ! Notenhals nach oben soll Pause oh.Taktstr.darstellen ' .......................................................................... INC g_n% ! Eine Notenposition weiter @3_notenhals(1) ! Notenhals nach oben soll Pause mitTaktstr.darstellen ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 3_notenkopf(h|) !_: ' ---------------------------------------------------------------------------- ' h| ! Notenhals unten:=0, oben:=1 ' ---------------------------------------------------------------------------- LOCAL kb| ! Notenkopf: Pboxbreite LOCAL kh| ! Notenkopf: Pboxhöhe LOCAL kx| ! Notenkopf: x-Startkoordinate LOCAL kx| ! Notenkopf: y-Startkoordinate LOCAL x1% ! links LOCAL y1% ! oben LOCAL x2% ! rechts LOCAL y2% ! unten ' ............................................................................ LET kb|=6 ! Notenkopf: Pboxbreite LET kh|=4 ! Notenkopf: Pboxhöhe LET kx|=5 ! Notenkopf: x-Startkoordinate LET ky|=15 ! Notenkopf: y-Startkoordinate ' ............................................................................ LET x1%=g_x%(g_n%)+kx|! links LET y1%=g_y%(g_n%)+ky|! oben LET x2%=x1%+kb| ! rechts LET y2%=y1%+kh| ! unten ' ............................................................................ IF h|=1 ! F Notenhals oben: LET x1%=g_x%(g_n%)+g_nb|-kx| ! links wird zu rechts LET y1%=g_y%(g_n%)+g_nzlh|-ky| ! oben wird zu unten LET x2%=x1%-kb| ! rechts wird zu links LET y2%=y1%-kh| ! unten wird zu oben ENDIF ! EF Notenhals oben ' ............................................................................ PBOX x1%,y1%,x2%,y2% ! Notenkopf malen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_notenhals(h|) !_: ' ---------------------------------------------------------------------------- ' h| ! Notenhals unten:=0, oben:=1 ' ---------------------------------------------------------------------------- LOCAL lx| ! x-Startwert LOCAL ly| ! y-Startwert LOCAL ll| ! Notenhalslänge LOCAL x% ! x-Standort LOCAL y1% ! y-Start LOCAL y2% ! y-Ende ' ............................................................................ LET lx|=5 ! x-Startwert LET ly|=20 ! y-Startwert LET ll|=24 ! Notenhalslänge ' ............................................................................ LET x%=g_x%(g_n%)+lx| ! x-Standort LET y1%=g_y%(g_n%)+ly|! y-Start LET y2%=y1%+ll| ! y-Ende ' ............................................................................ IF h|=1 ! F Notenhals oben: LET x%=g_x%(g_n%)+g_nb|-lx| ! links wird zu rechts LET y1%=g_y%(g_n%)+g_nzlh|-ly| ! oben wird zu unten LET y2%=y1%-ll| ! unten wird zu oben ENDIF ! EF Notenhals oben ' ............................................................................ LINE x%,y1%,x%,y2% ! Notenhals malen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_taktstrich !_: ' ---------------------------------------------------------------------------- LOCAL lx| ! x-Startwert LOCAL ly| ! y-Startwert LOCAL ll| ! Taktstrichlänge LOCAL x% ! x-Standort LOCAL y1% ! y-Start LOCAL y2% ! y-Ende ' ............................................................................ LET lx|=1 ! x-Startwert LET ly|=0 ! y-Startwert LET ll|=150 ! Taktstrichlänge ' ............................................................................ LET x%=g_x%(g_n%)+lx| ! x-Standort LET y1%=ly| ! y-Start LET y2%=ll| ! y-Ende ' ............................................................................ DEFLINE &X11111111111111111010101010101011,1,0,0 ! Gepunktete Linie LINE x%,y1%,x%,y2% ! Taktstrich malen DEFLINE 1,1,0 ! Durchgezogene Linie ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_kreuz(h|) !_: ' ---------------------------------------------------------------------------- ' h| ! Notenhals unten:=0, oben:=1 ' ---------------------------------------------------------------------------- LOCAL hb| ! Erhöhungszeichen=Kreuz: Pboxbreite LOCAL hh| ! Erhöhungszeichen=Kreuz: Pboxhöhe LOCAL hx| ! Erhöhungszeichen=Kreuz: x-Startkoordinate LOCAL hx| ! Erhöhungszeichen=Kreuz: y-Startkoordinate LOCAL x1% ! links LOCAL y1% ! oben LOCAL x2% ! rechts LOCAL y2% ! unten ' ............................................................................ LET hb|=5 ! Notenhöheninfo=Kreuz: Boxbreite LET hh|=4 ! Notenhöheninfo=Kreuz: Boxhöhe LET hx|=5 ! Notenhöheninfo=Kreuz: x-Startkoordinate LET hy|=26 ! Notenhöheninfo=Kreuz: y-Startkoordinate ' ............................................................................ LET x1%=g_x%(g_n%)+hx|! links LET y1%=g_y%(g_n%)+hy|! oben LET x2%=x1%+hb| ! rechts LET y2%=y1%+hh| ! unten ' ............................................................................ IF h|=1 ! F Notenhals oben: LET x1%=g_x%(g_n%)+g_nb|-hx| ! links wird zu rechts LET y1%=g_y%(g_n%)+g_nzlh|-hy| ! oben wird zu unten LET x2%=x1%-hb| ! rechts wird zu links LET y2%=y1%-hh| ! unten wird zu oben ENDIF ! EF Notenhals oben ' ............................................................................ BOX x1%,y1%,x2%,y2% ! Erhöhungszeichen=Kreuz malen IF h|=1 ! F Notenhals oben: BOX x1%-1,y1%,x2%-1,y2%! dickere Ränder links und rechts ELSE ! F Notenhals unten: BOX x1%+1,y1%,x2%+1,y2%! dickere Ränder links und rechts ENDIF ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_betonung(h|) !_: ' ---------------------------------------------------------------------------- ' h| ! Notenhals unten:=0, oben:=1 ' ---------------------------------------------------------------------------- LOCAL bb| ! Betonungszeichen: Pboxbreite LOCAL bh| ! Betonungszeichen: Pboxhöhe LOCAL bx| ! Betonungszeichen: x-Startkoordinate LOCAL bx| ! Betonungszeichen: y-Startkoordinate LOCAL x1% ! links LOCAL y1% ! oben LOCAL x2% ! rechts LOCAL y2% ! unten ' ............................................................................ LET bb|=4 ! Betonungszeichen: Boxbreite LET bh|=2 ! Betonungszeichen: Boxhöhe LET bx|=5 ! Betonungszeichen: x-Startkoordinate LET by|=22 ! Betonungszeichen: y-Startkoordinate ' ............................................................................ LET x1%=g_x%(g_n%)+bx|! links LET y1%=g_y%(g_n%)+by|! oben LET x2%=x1%+bb| ! rechts LET y2%=y1%+bh| ! unten ' ............................................................................ IF h|=1 ! F Notenhals oben: LET x1%=g_x%(g_n%)+g_nb|-bx| ! links wird zu rechts LET y1%=g_y%(g_n%)+g_nzlh|-by| ! oben wird zu unten LET x2%=x1%-bb| ! rechts wird zu links LET y2%=y1%-bh| ! unten wird zu oben ENDIF ! EF Notenhals oben ' ............................................................................ PBOX x1%,y1%,x2%,y2% ! Betonungszeichen malen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_gebundenzeichen(h|) !_: ' ---------------------------------------------------------------------------- ' h| ! Notenhals unten:=0, oben:=1 ' ---------------------------------------------------------------------------- LOCAL bb| ! Gebundenzeichen: Pboxbreite LOCAL bh| ! Gebundenzeichen: Pboxhöhe LOCAL bx| ! Gebundenzeichen: x-Startkoordinate LOCAL bx| ! Gebundenzeichen: y-Startkoordinate LOCAL x1% ! links LOCAL y1% ! oben LOCAL x2% ! rechts LOCAL y2% ! unten ' ............................................................................ LET gd|=6 ! Gebunden mit vorheriger Note: Boxbreite LET gh|=2 ! Gebunden mit vorheriger Note: Boxhöhe LET gx|=5 ! Gebunden mit vorheriger Note: x-Startkoordinate LET gy|=10 ! Gebunden mit vorheriger Note: y-Startkoordinate ' ............................................................................ LET x1%=g_x%(g_n%)+gx|! links LET y1%=g_y%(g_n%)+gy|! oben LET x2%=x1%+gd| ! rechts LET y2%=y1%+gh| ! unten ' ............................................................................ IF h|=1 ! F Notenhals oben: LET x1%=g_x%(g_n%)+g_nb|-gx| ! links wird zu rechts LET y1%=g_y%(g_n%)+g_nzlh|-gy| ! oben wird zu unten LET x2%=x1%-gd| ! rechts wird zu links LET y2%=y1%-gh| ! unten wird zu oben ENDIF ! EF Notenhals oben ' ............................................................................ BOX x1%,y1%,x2%,y2% ! Gebundenzeichen malen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_faehnchen(t|,h|) !_: ' ---------------------------------------------------------------------------- ' t| ! Anzahl der Fähnchen ' h| ! Notenhals unten:=0, oben:=1 ' ---------------------------------------------------------------------------- LOCAL ax1| ! ?-tel-Fähnchen, Linie a: x-Startkoordinate LOCAL ax2| ! ?-tel-Fähnchen, Linie a: x-Endkoordinate LOCAL bx2| ! ?-tel-Fähnchen, Linie b: x-Endkoordinate ' LOCAL a32y1| ! 32-tel-Fähnchen, Linie a: y-Startkoordinate LOCAL a32y2| ! 32-tel-Fähnchen, Linie a: y-Endkoordinate LOCAL b32y1| ! 32-tel-Fähnchen, Linie b: y-Startkoordinate ' LOCAL a16y1| ! 16-tel-Fähnchen, Linie a: y-Startkoordinate LOCAL a16y2| ! 16-tel-Fähnchen, Linie a: y-Endkoordinate LOCAL b16y1| ! 16-tel-Fähnchen, Linie b: y-Startkoordinate ' LOCAL a8y1| ! 8-tel-Fähnchen, Linie a: y-Startkoordinate LOCAL a8y2| ! 8-tel-Fähnchen, Linie a: y-Endkoordinate LOCAL b8y1| ! 8-tel-Fähnchen, Linie b: y-Startkoordinate ' LOCAL x% ! Speicher für Start-x-Wert des aktuellen Notenfensters LOCAL y% ! Speicher für Start-y-Wert des aktuellen Notenfensters ' LOCAL x1% ! links LOCAL y1% ! unten LOCAL x2% ! rechts LOCAL y2% ! oben ' ............................................................................ LET ax1|=6 ! ?-tel-Fähnchen, Linie a: x-Startkoordinate LET ax2|=9 ! ?-tel-Fähnchen, Linie a: x-Endkoordinate LET bx2|=10 ! ?-tel-Fähnchen, Linie b: x-Endkoordinate ' LET a32y1|=35 ! 32-tel-Fähnchen, Linie a: y-Startkoordinate LET a32y2|=32 ! 32-tel-Fähnchen, Linie a: y-Endkoordinate LET b32y1|=a32y1|+1 ! 32-tel-Fähnchen, Linie b: y-Startkoordinate ' LET a16y1|=39 ! 16-tel-Fähnchen, Linie a: y-Startkoordinate LET a16y2|=36 ! 16-tel-Fähnchen, Linie a: y-Endkoordinate LET b16y1|=a16y1|+1 ! 16-tel-Fähnchen, Linie b: y-Startkoordinate ' LET a8y1|=43 ! 8-tel-Fähnchen, Linie a: y-Startkoordinate LET a8y2|=40 ! 8-tel-Fähnchen, Linie a: y-Endkoordinate LET b8y1|=a8y1|+1 ! 8-tel-Fähnchen, Linie b: y-Startkoordinate ' LET x%=g_x%(g_n%) ! Start-x-Wert des Notenfensters in einfachere Variable LET y%=g_y%(g_n%) ! Start-y-Wert des Notenfensters in einfachere Variable ' ............................................................................ IF t|=0 ! F Kein Fähnchen verlangt: GOTO r_faehnchen ! verlasse unverrichteter Dinge die Prozedur ENDIF ! EF kein Fähnchen verlangt ' ............................................................................ ' ! A c h t e l - F ä h n c h e n : ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF h|=0 ! F Notenhals unten: LET x1%=x%+ax1| ! links LET y1%=y%+a8y1| ! unten LET x2%=x%+ax2| ! rechts LET y2%=y%+a8y2| ! oben ELSE IF h|=1 ! F Notenhals oben, Werte spiegeln: LET x1%=x%+g_nb|-ax1| ! aus links wird rechts LET y1%=y%+g_nzlh|-a8y1|! aus unten wird oben LET x2%=x%+g_nb|-ax2| ! aus rechts wird links LET y2%=y%+g_nzlh|-a8y2|! aus oben wird unten ENDIF ! EFU Notenhals unten / oben ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINE x1%,y1%,x2%,y2% ! 8-tel Notenfähnchen, Linie a malen ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF h|=0 ! F Notenhals unten: LET x1%=x%+ax1| ! links LET y1%=y%+b8y1| ! unten LET x2%=x%+bx2| ! rechts LET y2%=y%+a8y2| ! oben ELSE IF h|=1 ! F Notenhals oben, Werte spiegeln: LET x1%=x%+g_nb|-ax1| ! aus links wird rechts LET y1%=y%+g_nzlh|-b8y1|! aus unten wird oben LET x2%=x%+g_nb|-bx2| ! aus rechts wird links LET y2%=y%+g_nzlh|-a8y2|! aus oben wird unten ENDIF ! EF Notenhals oben ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINE x1%,y1%,x2%,y2% ! 8-tel Notenfähnchen, Linie b malen ' ............................................................................ IF t|=1 ! F Kein Fähnchen mehr verlangt: GOTO r_faehnchen ! verlasse nach getaner Arbeit die Prozedur ENDIF ! EF kein Fähnchen mehr verlangt ' ............................................................................ ' ! S e c h z e h n t e l - F ä h n c h e n : ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF h|=0 ! F Notenhals unten: LET x1%=x%+ax1| ! links LET y1%=y%+a16y1| ! unten LET x2%=x%+ax2| ! rechts LET y2%=y%+a16y2| ! oben ELSE IF h|=1 ! F Notenhals oben, Werte spiegeln: LET x1%=x%+g_nb|-ax1| ! aus links wird rechts LET y1%=y%+g_nzlh|-a16y1|! aus unten wird oben LET x2%=x%+g_nb|-ax2| ! aus rechts wird links LET y2%=y%+g_nzlh|-a16y2|! aus oben wird unten ENDIF ! EFU Notenhals unten / oben ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINE x1%,y1%,x2%,y2% ! 16-tel Notenfähnchen, Linie a malen ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF h|=0 ! F Notenhals unten: LET x1%=x%+ax1| ! links LET y1%=y%+b16y1| ! unten LET x2%=x%+bx2| ! rechts LET y2%=y%+a16y2| ! oben ELSE IF h|=1 ! F Notenhals oben, Werte spiegeln: LET x1%=x%+g_nb|-ax1| ! aus links wird rechts LET y1%=y%+g_nzlh|-b16y1|! aus unten wird oben LET x2%=x%+g_nb|-bx2| ! aus rechts wird links LET y2%=y%+g_nzlh|-a16y2|! aus oben wird unten ENDIF ! EF Notenhals oben ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINE x1%,y1%,x2%,y2% ! 16-tel Notenfähnchen, Linie b malen ' ............................................................................ IF t|=2 ! F Kein Fähnchen mehr verlangt: GOTO r_faehnchen ! verlasse nach getaner Arbeit die Prozedur ENDIF ! EF kein Fähnchen mehr verlangt ' ............................................................................ ' ! Z w e i u n d d r e i ß i g s t e l - F ä h n c h e n ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF h|=0 ! F Notenhals unten: LET x1%=x%+ax1| ! links LET y1%=y%+a32y1| ! unten LET x2%=x%+ax2| ! rechts LET y2%=y%+a32y2| ! oben ELSE IF h|=1 ! F Notenhals oben, Werte spiegeln: LET x1%=x%+g_nb|-ax1| ! aus links wird rechts LET y1%=y%+g_nzlh|-a32y1|! aus unten wird oben LET x2%=x%+g_nb|-ax2| ! aus rechts wird links LET y2%=y%+g_nzlh|-a32y2|! aus oben wird unten ENDIF ! EFU Notenhals unten / oben ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINE x1%,y1%,x2%,y2% ! 32-tel Notenfähnchen, Linie a malen ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF h|=0 ! F Notenhals unten: LET x1%=x%+ax1| ! links LET y1%=y%+b32y1| ! unten LET x2%=x%+bx2| ! rechts LET y2%=y%+a32y2| ! oben ELSE IF h|=1 ! F Notenhals oben, Werte spiegeln: LET x1%=x%+g_nb|-ax1| ! aus links wird rechts LET y1%=y%+g_nzlh|-b32y1|! aus unten wird oben LET x2%=x%+g_nb|-bx2| ! aus rechts wird links LET y2%=y%+g_nzlh|-a32y2|! aus oben wird unten ENDIF ! EF Notenhals oben ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINE x1%,y1%,x2%,y2% ! 32-tel Notenfähnchen, Linie b malen ' ............................................................................ r_faehnchen: ! Label zum vorzeitigen Verlassen der Prozedur ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_noten_foto(l|,v|,t|)!_: ' ---------------------------------------------------------------------------- ' l| ! Notenhals unten:=0, oben:=1 ' v| ! vertikale, logische Position des Negativs ' t| ! Fähnchenanzahl ' ---------------------------------------------------------------------------- LOCAL d| ! physikalische Vertikalposition LOCAL h| ! Zwischenspeicher für Notenzeilenhöhe minus 1 LOCAL nb| ! Zwischenspeicher für Notenbreite LOCAL a$ ! Bildschirmzwischenspeicher brauchts wegen Hilfslinien ' ............................................................................ ' ! N o t e n b i l d s p e i c h e r : ' g_nb$(g_tha|,g_tpa|,1,1) ! Notenbildspeicherarray, die Argumente sind: ' ! 1.) Tonhöhe (1-25) c1=1, c3=25 ' ! 2.) Periodendauerkennziffer (0-3) ' 0=1/4, 1=1/8, 2=1/16, 3=1/32 ' ! 3.) Gebunden mit Vorgängernote ? (Ja=1,Nein=0) ' ! 4.) Betonte Note ? (Ja=1,Nein=0) ' ............................................................................ LET rga%=-3 ! Richtiger Gebundenzeichenabstand: beim Spiegeln der ' ! Noten mit Hals nach unten (um die mit Hals nach oben ' ! zu erreichen) ist der Abstand zum unteren Rand in- ' ! korrekt und wird durch rga% korrigiert (s.a. Bild) LET h|=g_nzlh|-2 ! Zwischenspeicher für Notenzeilenhöhe minus 2, weil: ' ! g_y%(?)+g_nzlh| bereits 1.Pkt v.nächstunteren Notenbe- ' ! reich, siehe auch Bild der Beispielnote! LET nb|=g_nb|-1 ! Zwischenspeicher für Notenbreite,spart immer 2 Zeichen SGET a$ ! Bildschirm retten ' ............................................................................ IF l|=0 ! F Notenhals unten: ' .......................................................................... IF v|=1 ! F 1. logische Vertikalposition = h1, Noten fotograf.: LET d|=8*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(12,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(12,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(12,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(12,t|,1,1) ELSE IF v|=2 ! F 2. logische Vertikalposition = c2, cis2 LET d|=7*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(13,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(13,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(13,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(13,t|,1,1) GET g_x%(5),g_y%(1)-d|,g_x%(5)+nb|,g_y%(5)+h|-d|,g_nb$(14,t|,0,0) GET g_x%(6),g_y%(2)-d|,g_x%(6)+nb|,g_y%(6)+h|-d|,g_nb$(14,t|,1,0) GET g_x%(7),g_y%(3)-d|,g_x%(7)+nb|,g_y%(7)+h|-d|,g_nb$(14,t|,0,1) GET g_x%(8),g_y%(4)-d|,g_x%(8)+nb|,g_y%(8)+h|-d|,g_nb$(14,t|,1,1) ELSE IF v|=3 ! F 3. logische Vertikalposition = d2, dis2 LET d|=6*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(15,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(15,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(15,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(15,t|,1,1) GET g_x%(5),g_y%(1)-d|,g_x%(5)+nb|,g_y%(5)+h|-d|,g_nb$(16,t|,0,0) GET g_x%(6),g_y%(2)-d|,g_x%(6)+nb|,g_y%(6)+h|-d|,g_nb$(16,t|,1,0) GET g_x%(7),g_y%(3)-d|,g_x%(7)+nb|,g_y%(7)+h|-d|,g_nb$(16,t|,0,1) GET g_x%(8),g_y%(4)-d|,g_x%(8)+nb|,g_y%(8)+h|-d|,g_nb$(16,t|,1,1) ELSE IF v|=4 ! F 4. logische Vertikalposition = e2 LET d|=5*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(17,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(17,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(17,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(17,t|,1,1) ELSE IF v|=5 ! F 5. logische Vertikalposition = f2, fis2 LET d|=4*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(18,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(18,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(18,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(18,t|,1,1) GET g_x%(5),g_y%(1)-d|,g_x%(5)+nb|,g_y%(5)+h|-d|,g_nb$(19,t|,0,0) GET g_x%(6),g_y%(2)-d|,g_x%(6)+nb|,g_y%(6)+h|-d|,g_nb$(19,t|,1,0) GET g_x%(7),g_y%(3)-d|,g_x%(7)+nb|,g_y%(7)+h|-d|,g_nb$(19,t|,0,1) GET g_x%(8),g_y%(4)-d|,g_x%(8)+nb|,g_y%(8)+h|-d|,g_nb$(19,t|,1,1) ELSE IF v|=6 ! F 6. logische Vertikalposition = g2, gis2 LET d|=3*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(20,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(20,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(20,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(20,t|,1,1) GET g_x%(5),g_y%(1)-d|,g_x%(5)+nb|,g_y%(5)+h|-d|,g_nb$(21,t|,0,0) GET g_x%(6),g_y%(2)-d|,g_x%(6)+nb|,g_y%(6)+h|-d|,g_nb$(21,t|,1,0) GET g_x%(7),g_y%(3)-d|,g_x%(7)+nb|,g_y%(7)+h|-d|,g_nb$(21,t|,0,1) GET g_x%(8),g_y%(4)-d|,g_x%(8)+nb|,g_y%(8)+h|-d|,g_nb$(21,t|,1,1) ELSE IF v|=7 ! F 7. logische Vertikalposition = a2, b2 @3_hilfslinie_a2 ! Hilfslinie fürs obere a malen LET d|=2*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(22,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(22,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(22,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(22,t|,1,1) GET g_x%(5),g_y%(1)-d|,g_x%(5)+nb|,g_y%(5)+h|-d|,g_nb$(23,t|,0,0) GET g_x%(6),g_y%(2)-d|,g_x%(6)+nb|,g_y%(6)+h|-d|,g_nb$(23,t|,1,0) GET g_x%(7),g_y%(3)-d|,g_x%(7)+nb|,g_y%(7)+h|-d|,g_nb$(23,t|,0,1) GET g_x%(8),g_y%(4)-d|,g_x%(8)+nb|,g_y%(8)+h|-d|,g_nb$(23,t|,1,1) SPUT a$ ! ursprünglichen Bildschirm wiederherstellen ELSE IF v|=8 ! F 8. logische Vertikalposition = h2 @3_hilfslinie_h2 ! Hilfslinie fürs obere h malen LET d|=1*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(24,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(24,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(24,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(24,t|,1,1) SPUT a$ ! ursprünglichen Bildschirm wiederherstellen ELSE IF v|=9 ! F 9. logische Vertikalposition = c3 @3_hilfslinie_a2 ! Hilfslinie fürs obere a malen @3_hilfslinie_c3 ! untere Hilfslinie fürs obere c malen LET d|=0*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(1),g_y%(1)-d|,g_x%(1)+nb|,g_y%(1)+h|-d|,g_nb$(25,t|,0,0) GET g_x%(2),g_y%(2)-d|,g_x%(2)+nb|,g_y%(2)+h|-d|,g_nb$(25,t|,1,0) GET g_x%(3),g_y%(3)-d|,g_x%(3)+nb|,g_y%(3)+h|-d|,g_nb$(25,t|,0,1) GET g_x%(4),g_y%(4)-d|,g_x%(4)+nb|,g_y%(4)+h|-d|,g_nb$(25,t|,1,1) SPUT a$ ! ursprünglichen Bildschirm wiederherstellen ENDIF ! EFU logische Vertikalpositionen 1-9: Hals unten ' .......................................................................... ELSE IF l|=1 ! F Notenhals oben: ' .......................................................................... IF v|=1 ! F 1. logische Vertikalposition = a1, b1 LET d%=rga%+5*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(9),g_y%(9)+d%,g_x%(9)+nb|,g_y%(9)+h|+d%,g_nb$(10,t|,0,0) GET g_x%(10),g_y%(10)+d%,g_x%(10)+nb|,g_y%(10)+h|+d%,g_nb$(10,t|,1,0) GET g_x%(11),g_y%(11)+d%,g_x%(11)+nb|,g_y%(11)+h|+d%,g_nb$(10,t|,0,1) GET g_x%(12),g_y%(12)+d%,g_x%(12)+nb|,g_y%(12)+h|+d%,g_nb$(10,t|,1,1) GET g_x%(13),g_y%(13)+d%,g_x%(13)+nb|,g_y%(13)+h|+d%,g_nb$(11,t|,0,0) GET g_x%(14),g_y%(14)+d%,g_x%(14)+nb|,g_y%(14)+h|+d%,g_nb$(11,t|,1,0) GET g_x%(15),g_y%(15)+d%,g_x%(15)+nb|,g_y%(15)+h|+d%,g_nb$(11,t|,0,1) GET g_x%(16),g_y%(16)+d%,g_x%(16)+nb|,g_y%(16)+h|+d%,g_nb$(11,t|,1,1) ELSE IF v|=2 ! F 2. logische Vertikalposition = g1, gis1 LET d%=rga%+4*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(9),g_y%(9)+d%,g_x%(9)+nb|,g_y%(9)+h|+d%,g_nb$(8,t|,0,0) GET g_x%(10),g_y%(10)+d%,g_x%(10)+nb|,g_y%(10)+h|+d%,g_nb$(8,t|,1,0) GET g_x%(11),g_y%(11)+d%,g_x%(11)+nb|,g_y%(11)+h|+d%,g_nb$(8,t|,0,1) GET g_x%(12),g_y%(12)+d%,g_x%(12)+nb|,g_y%(12)+h|+d%,g_nb$(8,t|,1,1) GET g_x%(13),g_y%(13)+d%,g_x%(13)+nb|,g_y%(13)+h|+d%,g_nb$(9,t|,0,0) GET g_x%(14),g_y%(14)+d%,g_x%(14)+nb|,g_y%(14)+h|+d%,g_nb$(9,t|,1,0) GET g_x%(15),g_y%(15)+d%,g_x%(15)+nb|,g_y%(15)+h|+d%,g_nb$(9,t|,0,1) GET g_x%(16),g_y%(16)+d%,g_x%(16)+nb|,g_y%(16)+h|+d%,g_nb$(9,t|,1,1) ELSE IF v|=3 ! F 3. logische Vertikalposition = f1, fis1 LET d%=rga%+3*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(9),g_y%(9)+d%,g_x%(9)+nb|,g_y%(9)+h|+d%,g_nb$(6,t|,0,0) GET g_x%(10),g_y%(10)+d%,g_x%(10)+nb|,g_y%(10)+h|+d%,g_nb$(6,t|,1,0) GET g_x%(11),g_y%(11)+d%,g_x%(11)+nb|,g_y%(11)+h|+d%,g_nb$(6,t|,0,1) GET g_x%(12),g_y%(12)+d%,g_x%(12)+nb|,g_y%(12)+h|+d%,g_nb$(6,t|,1,1) GET g_x%(13),g_y%(13)+d%,g_x%(13)+nb|,g_y%(13)+h|+d%,g_nb$(7,t|,0,0) GET g_x%(14),g_y%(14)+d%,g_x%(14)+nb|,g_y%(14)+h|+d%,g_nb$(7,t|,1,0) GET g_x%(15),g_y%(15)+d%,g_x%(15)+nb|,g_y%(15)+h|+d%,g_nb$(7,t|,0,1) GET g_x%(16),g_y%(16)+d%,g_x%(16)+nb|,g_y%(16)+h|+d%,g_nb$(7,t|,1,1) ELSE IF v|=4 ! F 4. logische Vertikalposition = e1 LET d%=rga%+2*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(9),g_y%(9)+d%,g_x%(9)+nb|,g_y%(9)+h|+d%,g_nb$(5,t|,0,0) GET g_x%(10),g_y%(10)+d%,g_x%(10)+nb|,g_y%(10)+h|+d%,g_nb$(5,t|,1,0) GET g_x%(11),g_y%(11)+d%,g_x%(11)+nb|,g_y%(11)+h|+d%,g_nb$(5,t|,0,1) GET g_x%(12),g_y%(12)+d%,g_x%(12)+nb|,g_y%(12)+h|+d%,g_nb$(5,t|,1,1) ELSE IF v|=5 ! F 5. logische Vertikalposition = d1, dis1 LET d%=rga%+1*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(9),g_y%(9)+d%,g_x%(9)+nb|,g_y%(9)+h|+d%,g_nb$(3,t|,0,0) GET g_x%(10),g_y%(10)+d%,g_x%(10)+nb|,g_y%(10)+h|+d%,g_nb$(3,t|,1,0) GET g_x%(11),g_y%(11)+d%,g_x%(11)+nb|,g_y%(11)+h|+d%,g_nb$(3,t|,0,1) GET g_x%(12),g_y%(12)+d%,g_x%(12)+nb|,g_y%(12)+h|+d%,g_nb$(3,t|,1,1) GET g_x%(13),g_y%(13)+d%,g_x%(13)+nb|,g_y%(13)+h|+d%,g_nb$(4,t|,0,0) GET g_x%(14),g_y%(14)+d%,g_x%(14)+nb|,g_y%(14)+h|+d%,g_nb$(4,t|,1,0) GET g_x%(15),g_y%(15)+d%,g_x%(15)+nb|,g_y%(15)+h|+d%,g_nb$(4,t|,0,1) GET g_x%(16),g_y%(16)+d%,g_x%(16)+nb|,g_y%(16)+h|+d%,g_nb$(4,t|,1,1) ELSE IF v|=6 ! F 6. logische Vertikalposition = c1, cis1 @3_hilfslinie_c1(rga%) ! Hilfslinie fürs unterste c malen LET d%=rga%+0*(g_la|/2)! physikalische Vertikalposition festlegen GET g_x%(9),g_y%(9)+d%,g_x%(9)+nb|,g_y%(9)+h|+d%,g_nb$(1,t|,0,0) GET g_x%(10),g_y%(10)+d%,g_x%(10)+nb|,g_y%(10)+h|+d%,g_nb$(1,t|,1,0) GET g_x%(11),g_y%(11)+d%,g_x%(11)+nb|,g_y%(11)+h|+d%,g_nb$(1,t|,0,1) GET g_x%(12),g_y%(12)+d%,g_x%(12)+nb|,g_y%(12)+h|+d%,g_nb$(1,t|,1,1) GET g_x%(13),g_y%(13)+d%,g_x%(13)+nb|,g_y%(13)+h|+d%,g_nb$(2,t|,0,0) GET g_x%(14),g_y%(14)+d%,g_x%(14)+nb|,g_y%(14)+h|+d%,g_nb$(2,t|,1,0) GET g_x%(15),g_y%(15)+d%,g_x%(15)+nb|,g_y%(15)+h|+d%,g_nb$(2,t|,0,1) GET g_x%(16),g_y%(16)+d%,g_x%(16)+nb|,g_y%(16)+h|+d%,g_nb$(2,t|,1,1) SPUT a$ ! ursprünglichen Bildschirm wiederherstellen ENDIF ! EFU logische Vertikalpositionen 1-6: Hals oben ' .......................................................................... ENDIF ! EFU Notenhals unten / oben ' ............................................................................ ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_pausen_foto(l|,t|) !_: ' ---------------------------------------------------------------------------- ' ! Diese Prozedur ist der '2_noten_foto()' sehr ähnlich. ' ............................................................................ ' l| ! Cursorpostion für die Pause ist wohl immer gleich=17 ' t| ! Fähnchenanzahl=Pausendauer ' ............................................................................ LOCAL d| ! physikalische Vertikalposition LOCAL h| ! Zwischenspeicher für Notenzeilenhöhe minus 1 LOCAL nb| ! Zwischenspeicher für Notenbreite ' ............................................................................ LET rga%=-3 ! Richtiger Gebundenzeichenabstand: beim Spiegeln der ' ! Noten mit Hals nach unten (um die mit Hals nach oben ' ! zu erreichen) ist der Abstand zum unteren Rand in- ' ! korrekt und wird durch rga% korrigiert (s.a. Bild) LET h|=g_nzlh|-2 ! Zwischenspeicher für Notenzeilenhöhe minus 2, weil: ' ! g_y%(?)+g_nzlh| bereits 1.Pkt v.nächstunteren Notenber LET nb|=g_nb|-1 ! Zwischenspeicher für Notenbreite,spart immer 2 Zeichen ' ............................................................................ LET d%=rga%+5*(g_la|/2)! physikalische Vertikalposition festlegen ' ! Pause ohne Taktstrich, 'ungebunden': GET g_x%(17),g_y%(17)+d%,g_x%(17)+nb|,g_y%(17)+h|+d%,g_nb$(26,t|,0,0) ' ! Pause ohne Taktstrich, 'gebunden': GET g_x%(17),g_y%(17)+d%,g_x%(17)+nb|,g_y%(17)+h|+d%,g_nb$(26,t|,1,0) ' ! Pause mit Taktstrich, 'ungebunden': GET g_x%(18),g_y%(18)+d%,g_x%(18)+nb|,g_y%(18)+h|+d%,g_nb$(26,t|,0,1) ' ! Pause mit Taktstrich, 'gebunden': GET g_x%(18),g_y%(18)+d%,g_x%(18)+nb|,g_y%(18)+h|+d%,g_nb$(26,t|,1,1) ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_hilfslinie_a2 !_: ' ---------------------------------------------------------------------------- LOCAL ha2x| ! Hilfslinie a2: x-Startkoordinate LOCAL ha2y| ! Hilfslinie a2: y-Startkoordinate LOCAL hd| ! Hilflinienbreite LOCAL x1% ! links LOCAL y% ! y-Koordinate LOCAL x2% ! rechts ' ............................................................................ LET ha2x|=4 ! Hilfslinie a2: x-Startkoordinate LET ha2y|=17 ! Hilfslinie a2: y-Startkoordinate LET hd|=9 ! Hilflinienbreite ' ............................................................................ FOR i|=1 TO 8 ! Alle Noten mit Hals nach unten durch LET x1%=g_x%(i|)+ha2x|! links LET y%=g_y%(i|)+ha2y|! y-Koordinate LET x2%=x1%+hd| ! rechts LINE x1%,y%,x2%,y% ! Hilfslinie malen NEXT i| ! Nächste Note mit Hals nach unten ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_hilfslinie_h2 !_: ' ---------------------------------------------------------------------------- LOCAL hh2x| ! Hilfslinie h2: x-Startkoordinate LOCAL hh2y| ! Hilfslinie h2: y-Startkoordinate LOCAL hd| ! Hilflinienbreite LOCAL x1% ! links LOCAL y% ! y-Koordinate LOCAL x2% ! rechts ' ............................................................................ LET hh2x|=4 ! Hilfslinie h2: x-Startkoordinate LET hh2y|=20 ! Hilfslinie h2: y-Startkoordinate LET hd|=9 ! Hilflinienbreite ' ............................................................................ FOR i|=1 TO 8 ! Alle Noten mit Hals nach unten durch LET x1%=g_x%(i|)+hh2x|! links LET y%=g_y%(i|)+hh2y|! y-Koordinate LET x2%=x1%+hd| ! rechts LINE x1%,y%,x2%,y% ! Hilfslinie malen NEXT i| ! Nächste Note mit Hals nach unten ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_hilfslinie_c3 !_: ' ---------------------------------------------------------------------------- LOCAL hc3x| ! Hilfslinie c3: x-Startkoordinate LOCAL hc3y| ! Hilfslinie c3: y-Startkoordinate LOCAL hd| ! Hilflinienbreite LOCAL x1% ! links LOCAL y% ! y-Koordinate LOCAL x2% ! rechts ' ............................................................................ LET hc3x|=4 ! Hilfslinie c3: x-Startkoordinate LET hc3y|=23 ! Hilfslinie c3: y-Startkoordinate LET hd|=9 ! Hilflinienbreite ' ............................................................................ FOR i|=1 TO 8 ! Alle Noten mit Hals nach unten durch LET x1%=g_x%(i|)+hc3x|! links LET y%=g_y%(i|)+hc3y|! y-Koordinate LET x2%=x1%+hd| ! rechts LINE x1%,y%,x2%,y% ! Hilfslinie malen NEXT i| ! Nächste Note mit Hals nach unten ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_hilfslinie_c1(yk%) !_: ' ---------------------------------------------------------------------------- ' yk% ! y-Korrekturfaktor (s.a. Bild unter 'rga%') ' ---------------------------------------------------------------------------- LOCAL hc1x| ! Hilfslinie c1: x-Startkoordinate LOCAL hc1y| ! Hilfslinie c1: y-Startkoordinate LOCAL hd| ! Hilflinienbreite LOCAL x1% ! links LOCAL y% ! y-Koordinate LOCAL x2% ! rechts ' ............................................................................ LET hc1x|=4 ! Hilfslinie c1: x-Startkoordinate LET hc1y|=59 ! Hilfslinie c1: y-Startkoordinate LET hd|=9 ! Hilflinienbreite ' ............................................................................ FOR i|=9 TO 16 ! Alle Noten mit Hals nach oben durch LET x1%=g_x%(i|)+hc1x|! links LET y%=g_y%(i|)+hc1y|+yk%! y-Koordinate LET x2%=x1%+hd| ! rechts LINE x1%,y%,x2%,y% ! Hilfslinie malen NEXT i| ! Nächste Note mit Hals nach oben ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 1_notenlinien !_: ' ---------------------------------------------------------------------------- LOCAL n1y| ! Pos. 1.Notenlinie: g_y%(?)+n1y| LOCAL npz| ! Anzahl der Noten pro Zeile berechnen: LOCAL i| ! Notenzeilenzähler LOCAL j| ! Notenlinienzähler ' ............................................................................ LET n1y|=29 ! Pos. 1.Notenlinie: g_y%(?)+n1y|(s.a.'invers') LET npz|=g_bb%/(g_nb|) ! Anzahl der Noten pro Zeile berechnen: ' ............................................................................ FOR i|=1 TO g_za| ! Alle Notenzeilen durch FOR j|=1 TO 5 ! Alle Notenlinien durch LET y%=g_y%(1+(i|-1)*npz|)+n1y|+(j|-1)*g_la| ! Notenlinien-y-Koordinate LINE 0,y%,g_bb%,y% ! Notenlinie zeichnen NEXT j| ! nächste Notenlinie NEXT i| ! nächste Notenzeile ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_begrenzungslinien !_: ' ---------------------------------------------------------------------------- LOCAL npz| ! Anzahl der Noten pro Zeile berechnen: LOCAL i| ! Notenzeilenzähler ' ............................................................................ LET npz|=g_bb%/(g_nb|) ! Anzahl der Noten pro Zeile berechnen: ' ............................................................................ FOR i|=1 TO g_za| ! Alle Notenzeilen durch LET y%=g_y%(1+(i|-1)*npz|)-1! y-Koordinate der oberen Begrenzungslinie LINE 0,y%,g_bb%,y% ! Obere Begrenzungslinie zeichnen NEXT i| ! Nächste Notenzeile ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_klaviatur !_: ' ---------------------------------------------------------------------------- LOCAL ntb| ! Notentastenbreite LOCAL ptb| ! Pausentastenbreite LOCAL i| ! Tastenzähler LOCAL x1% ! links LOCAL y1% ! oben LOCAL x2% ! rechts LOCAL y2% ! unten ' ............................................................................ LET ntb|=g_ntb| ! Notentastenbreite LET ptb|=g_ptb| ! Pausentastenbreite LET y1%=0 ! oben LET y2%=g_mh|-1 ! unten=Menühöhe-1 ' ............................................................................ FOR i|=1 TO g_tha|+1 ! Alle Notentasten durch LET x1%=ptb|+(i|-1)*ntb| ! links LET x2%=ptb|+i|*ntb| ! rechts LINE x1%,y1%,x1%,y2% ! Tastenbegrenzung links ' ! F schwarze Taste: IF i|=2 OR i|=4 OR i|=7 OR i|=9 OR i|=11 OR i|=14 OR i|=16 OR i|=19 OR i|=21 OR i|=23 PBOX x1%,y1%,x2%,y2% ! schwarze Taste malen ENDIF ! EF schwarze Taste NEXT i| ! nächste Notentaste ' ............................................................................ BOUNDARY 0 ! Rand ausschalten DEFFILL 1,2,4 ! Muster für Pausentaste PBOX x1%+1,y1%,x1%+ptb|,y2%-1 ! Pausentaste rechts PBOX 0,y1%,ptb|-1,y2%-1 ! Pausentaste links DEFFILL 1,2,8 ! Muster wieder schwarz BOUNDARY 1 ! Rand wieder einschalten ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,g_kl$ ! Klaviatur fotografieren ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 0_midi_vorbereiten !_: ' ---------------------------------------------------------------------------- IF g_midi!=TRUE ! F Midi ein: OUT 3,192,g_k1| ! Sound für Kanal 1 OUT 3,193,g_k2| ! Sound für Kanal 2 OUT 3,194,g_k3| ! Sound für Kanal 3 ENDIF ! d ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 0_hauptfile_laden !_: ' ---------------------------------------------------------------------------- LOCAL dummy| ! Dummy für Alertbox LOCAL dummy% ! Dummy für RECALL-Befehl LOCAL m$ ! Speicher für Filename ' ............................................................................ IF (NOT EXIST(g_hf$)) OR g_w! ! f Notenhauptdatei nicht auf Disk oder ' ! Wahlmöglichkeit erwünscht: FILESELECT "A:\*.NTN",m$,m$ ! Fileselectbox IF m$="" OR NOT EXIST(m$) ! F Abbruch gewählt: @a_alert("Hauptfile wird im RAM neuangelegt!/ok!",dummy|) LET g_stueck$(0)=STRING$(g_stka|*8,"_")!Inhaltsverz. mit Leerz. auffüllen LET g_stueck$(1)=g_stueck$(0) ! Datumteil FOR s%=2 TO g_stka|+1 ! Alle Stücke durch LET g_stueck$(s%)=STRING$(800,"@") ! Mit Leerzeichen auffüllen NEXT s% ! nächstes Stück GOTO raus_0_hauptfile_laden ! d ELSE ! sonst: LET g_hf$=RIGHT$(m$,LEN(m$)-3) ! 'A:\' wegschneiden ENDIF ! d ENDIF ! d ' ............................................................................ OPEN "I",#1,g_hf$ ! Hauptnotenfile öffnen RECALL #1,g_stueck$(),-1,dummy% ! Array laden CLOSE #1 ! File schließen ' ............................................................................ raus_0_hauptfile_laden: ! d @1_fileselectboxfoto ! Fileselectbox fotografieren SPUT g_lb$ ! Löschbildschirm PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_fileselectboxfoto !_: ' ---------------------------------------------------------------------------- ' Hier wird die Fileselectbox angezeigt und fotografiert. Diese Prozedur wird ' auch von 'abspeichern' aus aufgerufen. ' ---------------------------------------------------------------------------- LOCAL i| ! Zählvariable LOCAL a| ! Wahlvariable für Menü LOCAL m| ! Maustastenvar. für Menü LOCAL c$ ! Bildschirmnegativ DIM a$(g_stka|) ! Menüeintragsfelderarray dim. DIM a%(g_stka|) ! Nummerierungsarray dim. ' ............................................................................ SGET c$ ! Bildschirm retten ' ............................................................................ SPUT g_lb$ ! Löschbild ausgeben, wichtig, ' ! weil diese Proc.auch von ' ! 'abspeichern' aus aufger.wird ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Menüeinträge durch LET a$(i|)=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Ins Menüeintragsfeld kopieren LET a%(i|)=i| ! Nummerierungsarrayeintrag NEXT i| ! nächster Menüeintrag ' ............................................................................ QSORT a$(),g_stka|+1,a%() ! Sortieren ' ............................................................................ @a_menue(-1,0,0,0,0,-1,4,4,8,20,m|,a|,a$(),d!()) ! Menüprozedur aufrufen LET a|=a%(a|) ! wirkliche Wahlnummer ermitteln ' ............................................................................ SGET g_fsb$ ! Fileselectbox fotografieren ' ............................................................................ SPUT c$ ! Bildschirm wieder herstellen ' ............................................................................ ERASE a$() ! Menüeintragsarray löschen ERASE a%() ! Nummerierungsarray löschen ' ---------------------------------------------------------------------------- RETURN ' ############################################################################## ' N o t e n e i n g a b e : ' ############################################################################## > PROCEDURE 0_hauptschleife !_: ' ---------------------------------------------------------------------------- ' Dies ist die oberste Ebene des Hauptprogramms. In der Schleife wird erst ' eine Unterprozedur aufgerufen, die Nach Maus- und Tastatur fragt. Wurde ' dort eine Eingabe gemacht, geht's hier wieder weiter. Es wird untersucht, ' welcher der Befehle in der Tabelle (oder Helptaste) angesprochen wurde und ' daraufhin entsprechend verzweigt. Nach Beendigung des Befehls geht's dann ' wieder von vorne los, usw. bis zum bestätigten Befehl 'Programmende'. ' ---------------------------------------------------------------------------- LOCAL t| ! Help-Taste? Undo-Taste? LOCAL o| ! - 2 Oktaven ? LOCAL x% ! Maus-x-Koordinate LOCAL y% ! Maus-y-Koordinate ' ---------------------------------------------------------------------------- ' Achtung! Erst Zeilen-, dann Spaltennummer ! ! ! ' ' ' 1.Spalte: 2.Spalte: 3.Spalte: 4.Spalte: 5.Spalte: ' ' | linksoben | Notentaste | rechtsoben | Notentext | Cursor | ' ' |--------------------------------------------------------------| ' 1 LMT | Pause | 1/8 Note | Pause | Cursorpos. | Taktstr. | ' |------------+------------+------------+------------+----------| ' 2 RMT | Hauptmenü | Nur Ton | Backspace | Abspielen | Fähnchen | ' |--------------------------------------------------------------| DO LET t|=0 LET o|=0 @1_a(x%,y%,o|,t|) IF t|=1 @1_helptext ELSE IF t|=2 @1_undo ELSE IF g_zs!(1,1) ! 1. Zeile: -------------------------------------------- @1_write(0,x%) ! Pause ELSE IF g_zs!(1,2) @1_write(o|,x%) ! 1/8 Note ELSE IF g_zs!(1,3) @1_write(0,x%) ! Pause ELSE IF g_zs!(1,4) @1_neu_cpos(x%,y%) ! Cursorpos. ELSE IF g_zs!(1,5) @1_takt_setzen ! Taktstr. ELSE IF g_zs!(2,1) ! 2. Zeile: -------------------------------------------- @0_hauptmenue ! Hauptmenü ELSE IF g_zs!(2,2) @1_nur_ton(o|,x%) ! Nur Ton ELSE IF g_zs!(2,3) @1_backspace ! Backspace ELSE IF g_zs!(2,4) @1_spielen(x%,y%) ! Abspielen ELSE IF g_zs!(2,5) @1_faehnchen ! Fähnchen ENDIF ' .......................................................................... LOOP ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_a(VAR x%,y%,v|,k|) !_: ' ---------------------------------------------------------------------------- ' In dieser Prozedur werden Maus und Tastatur abgefragt auf: ' Maustasten, Mauskoordinaten, Alternate-Taste, Helptaste ' Die der Befehlstabelle (siehe 'hauptschleife' oder 'Dokumentation') ' entsprechenden Bedingungen werden abgefragt und die Ergebnisse in einem ' Boolean-Array zurückübergeben, das ist: g_zs!() . ' ---------------------------------------------------------------------------- ' ' x% ! Maus-x-Koordinate ' y% ! Maus-y-Koordinate ' v| ! Minuszweioktavenflag gesetzt ? ' k| ! =1 f Help-taste, =2 f Undotaste ' g_zs!() ! Array für Befehlsanalyse ' LOCAL lmt! ! Linke Maustaste ? -1=ja, 0=nein LOCAL rmt! ! rechte Maustaste ? -1=ja, 0=nein LOCAL jnb! ! -1=Notenbereich 0=Klaviatur ' LOCAL bs! ! Bildschirm schwarz gewesen ? ' LOCAL m| ! Maustaste LOCAL dummy| ! Bei Mausabfrage Tastaturinfo überflüssig LOCAL midi| ! Midi-Code-Variable ' LOCAL n% ! Notennummer unterm Mauspfeil LOCAL t% ! Zeitmesser für Bildschirmabschaltung ' LOCAL r% ! Speicher für Tastaturcode(Alt/Contr)von: BIOS(11,-1) ' LOCAL mx% ! X-Koordinate der Maus merken LOCAL my% ! Y-Koordinate der Maus merken ' LOCAL s$ ! Speicher für Tastaturcode (Help-Taste) ' LOCAL a$ ! Negativspeicher für Bildschirmrettung ' LOCAL m$ ! Midiinformation ' DIM z!(5) ! Zeilenarray DIM s!(5) ! Spaltenarray ' ............................................................................ ' 1. ) M a u s - u n d T a s t a t u r a b f r a g e : ' ............................................................................ SHOWM ! Mauspfeil zeigen ' ............................................................................ REPEAT ! Warteschleife zum Entleeren von Maus-und Tast.puffer LET r%=BIOS(11,-1) ! F noch Taste, in r% merken UNTIL MOUSEK=0 AND INKEY$="" AND r%<>2 AND r%<>16+2 ! es braucht inkey und r% ' r%=2 oder r%=16+2 bedeutet Shift (Backspace), das soll keine automatische ' Wiederholung bekommen, also stoppen. ' ............................................................................ REPEAT ! Abfrageschleife,analysiert nur,ob Maus od.Tastatur: ' .......................................................................... ' ! S c h w a r z s c h a l t u n g : INC t% ! Zeitmesser raufsetzen IF t%=50000 ! F Zeit für Bildschirmabschaltung: HIDEM ! Maus weg IF bs!=FALSE ! F Bildschirm bisher noch nicht schwarz SGET a$ ! Bildschirm retten ENDIF ! d PBOX 0,0,g_bb%-1,g_bh%-1! Bildschirm schwarz LET bs!=TRUE ! Bildschirm schwarz merken LET t%=0 ! Weiterlaufen ohne Overflow, deshalb null setzen ENDIF ! d IF (mx%<>MOUSEX OR my%<>MOUSEY) AND bs!=TRUE! F Mausbewegung + Blds.schwarz LET t%=0 ! Weiterlaufen ohne Overflow LET bs!=FALSE ! Bildschirm nicht mehr schwarz SPUT a$ ! Bildschirm wieder herstellen SHOWM ! Maus her ENDIF ! d LET mx%=MOUSEX ! X-Koordinate der Maus merken LET my%=MOUSEY ! Y-Koordinate der Maus merken ' .......................................................................... ' ! E n t g ü l t i g e A b f r a g e : MOUSE x%,y%,m| ! Mausdaten übermitteln LET s$=INKEY$ ! Taste ? LET m$=INPMID$ ! Midiinfo ? LET r%=BIOS(11,-1) ! F zusätzliche Taste, in r% merken ' Alternate: 8, Shiftlinks: 2, Control:4 , bei CapsLock: +16, Shiftrechts:1 IF ASC(s$)=97 OR ASC(s$)=65 ! F 'a' oder 'A' gedrückt: Stück spielen LET m|=2 ! linke Maustaste simulieren LET x%=g_x%(1)+1 ! x-Mauskoordinate auf 1.Note LET y%=g_y%(1)+1 ! y-Mauskoordinate auf 1.Note ENDIF ! d IF r%=2 OR r%=16+2 ! F Linksshift gedrückt: Wie Backspace=rechte Pausent. LET m|=2 ! rechte Maustaste simulieren LET x%=g_bb%-2 ! x-Mauskoordinate rechts simulieren LET y%=1 ! y-Mauskoordinate oben simulieren ENDIF ! d IF ASC(s$)=27 ! F "Esc"-Taste :Wie Hauptmenü=linke Pausentaste LET m|=2 ! rechte Maustaste simulieren LET x%=1 ! x-Mauskoordinate links simulieren LET y%=1 ! y-Mauskoordinate oben simulieren ENDIF ! d IF s$=" " ! F Space gedrückt: Wie irgendeine Pausentaste LET m|=1 ! linke Maustaste simulieren LET x%=1 ! x-Mauskoordinate links simulieren LET y%=1 ! y-Mauskoordinate oben simulieren ENDIF ! d IF r%=4 OR r%=16+4 ! F Control gedrückt: Cursor nach links IF g_n%>1 ! F links von Cursor noch was ist: LET m|=1 ! linke Maustaste simulieren LET x%=g_x%(g_n%-1)+1 ! x-Mauskoordinate auf Note links v. akt. Cursor LET y%=g_y%(g_n%-1)+1 ! y-Mauskoordinate auf Note links v. akt. Cursor ELSE ! F links vom Cursor nichts mehr ist: LET r%=0 ! Keine weitere Botschaft mehr ENDIF ! d ENDIF ! d IF ASC(s$)=9 AND g_n%<g_os% ! F "Tab"-Taste gedrückt: Cursor nach rechts IF g_n%<g_os% ! F rechts von Cursor noch was sein kann: LET m|=1 ! linke Maustaste simulieren LET x%=g_x%(g_n%+1)+1 ! x-Mauskoordinate auf Note links v. akt. Cursor LET y%=g_y%(g_n%+1)+1 ! y-Mauskoordinate auf Note links v. akt. Cursor ELSE ! F rechts vom Cursor nichts mehr ist: LET s$="" ! Keine weitere Botschaft mehr ENDIF ! d ENDIF ! d ' .......................................................................... ' ! B e i M i d i a u f r ä u m e n : IF m$<>"" AND (r%=8 OR r%=16+8) ! F was in Midi kam und Alternate-Taste: IF RIGHT$(m$,1)="@" ! F letzte Meldung: Ton ein: LET m$=INPMID$ ! 'Ton aus'-Meldung holen ENDIF ! d LET midi|=ASC(LEFT$(m$,1)) ! Tonhöhe feststellen ENDIF ! d ' .......................................................................... UNTIL m| OR s$<>"" OR midi|<>0 ! F Eingabe ' ............................................................................ IF bs! ! F Bildschirm noch schwarz: SPUT a$ ! Bildschirm wieder herstellen SHOWM ! Maus her ENDIF ! d ' ............................................................................ IF NOT g_midi! ! F kein Midi-Keyboard angeschlossen: WAVE 0,0 ! Ton aus ELSE ! F Midi-Keyboard angeschlossen OUT 3,128,g_mt1|,1 ! alten Ton aus Kanal 1 OUT 3,128,g_mt1|-24,1 ! alten Taktstrichton aus Kanal 1 OUT 3,129,g_mt2|,1 ! alten Ton aus Kanal 2 OUT 3,130,g_perc| ! alten Ton aus Kanal 3 ENDIF ! d ' ............................................................................ ' 2. ) e r s t e P e r i p h e r i e e i n g a b e a u s w e r t u n g : ' ............................................................................ IF m$<>"" ! F Midi-Eingabe IF midi|>59 AND midi|<59+26 ! F 'legale' Tonhöhe für Oktaven Nr. 3 und 4 LET midi|=midi|-59 ! tonhöhe einsetzen LET x%=midi|*g_ntb|+g_ptb|-5 ! x-Koordinate für entsprechende Taste LET y%=1 ! y-Koordinate für Klaviatur LET m|=1 ! linke Maustaste simulieren ELSE IF midi|>35 AND midi|<60 ! F 'legale' Tonhöhe für Oktaven Nr. 1 und 2 LET midi|=midi|-35 ! tonhöhe einsetzen LET x%=midi|*g_ntb|+g_ptb|-5 ! x-Koordinate für entsprechende Taste LET y%=1 ! y-Koordinate für Klaviatur LET m|=1 ! linke Maustaste simulieren LET v|=1 ! Minuszweioktavenflag gesetzt ENDIF ! d ENDIF ! d ' ............................................................................ LET lmt!=(2-m|) ! Linke Maustaste ? LET rmt!=NOT lmt! ! rechte Maustaste ? LET jnb!=(y%>g_mh|) ! auf Notenbereich ? LET z!(1)=lmt! ! Zeile [1] LET z!(2)=rmt! ! Zeile [2] LET s!(1)=(NOT jnb!) AND (x%<g_ptb|) ! Linke Pausentaste ? Spalte [a] LET s!(3)=(NOT jnb!) AND (x%>g_bb%-g_ptb|) ! Rechte Pausentaste ? Spalte [c] LET s!(2)=(NOT jnb!) AND (NOT s!(1)) AND (NOT s!(3)) ! Notentaste ?Spalte [b] IF y%>g_mh| ! f Maus auf Notenbereich : @3_notenr(x%,y%,n%) ! Welche Note liegt unter dem Mauspfeil? IF n%=g_n% ! F Cursor bereits auf Note unter Mauspfeil: LET s!(5)=TRUE ! Spalte [e] ELSE ! F Cursor nicht auf Note unter Mauspfeil: LET s!(4)=TRUE ! Spalte [d] ENDIF ! d ENDIF ! d ' ............................................................................ ' 3. ) Ü b e r g a b e p a r a m e t e r s e t z e n : ' ............................................................................ FOR i|=1 TO 2 ! Alle Zeilen durch FOR j|=1 TO 5 ! Alle Spalten durch LET g_zs!(i|,j|)=z!(i|) AND s!(j|) ! Zeilen-Spalten-Array setzen NEXT j| ! Nächste Spalte NEXT i| ! Nächste Zeile IF (g_zs!(1,2) OR g_zs!(2,2)) AND (r%=1 OR r%=16+1) ! F Rechtsshift gedrückt ' ! und außerdem eine Note eingegeben wurde oder 'Nurton' LET v|=1 ! Minuszweioktavenflag gesetzt ENDIF ! d IF ASC(RIGHT$(s$,1))=98 ! [Help]-Taste gedrückt ? LET k|=1 ! Übergabecode für diese Taste ELSE IF ASC(RIGHT$(s$,1))=97 AND LEN(s$)=2 ! [Undo]-Taste gedrückt ? LET k|=2 ! Übergabecode für diese Taste ENDIF ! d ' ............................................................................ ERASE z!(),s!() ! Einzelfelder weg, sonst mehrfaches Dimens. ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 1_helptext !_: ' ---------------------------------------------------------------------------- ' Hier wird der bereits im Vorbereitungsteil des Programms photographierte ' Hilfstext ausgegeben und auf einen Tastendruck gewartet ' ---------------------------------------------------------------------------- LOCAL ft| ! Nr. des 1. falschen Takts LOCAL tn| ! Taktnummer des letzten Taktes LOCAL i| ! Zähler für Textarray LOCAL j| ! Zähler fürs Invertieren LOCAL d| ! Dauer einer Viertelnote in Sekunden LOCAL t% ! Zeitmeßvariable LOCAL s% ! Anzahl der schwarzen Tasten LOCAL w% ! Anzahl der weißen Tasten LOCAL a$ ! Zwischenspeicher für Infotextzeile LOCAL b$ ! Bildschirmnegativ zum Bildschirm retten LOCAL i$ ! Infostring LOCAL t$ ! Negativ für unteren Textteil fürsInvertieren LOCAL takt$ ! Art des Takts DIM a$(20) ! Array für Infotext DIM n$(g_stka|) ! Array für Stücknamen ' ............................................................................ LET d|=8 ! Dauer einer Viertelnote in Zehntelsekunden ' ! Muß duch 2^3=8 teilbar sein: 3 Fänchen mögl. SGET b$ ! Bildschirm retten SPUT g_hp$ ! Helptext ausgeben ' ............................................................................ ' 1.) I n f o t e x t a r r a y f ü l l e n : ' ............................................................................ ' 1234567890123456789012345678901234567890 LET a$(1)="Freier Speicher in Bytes: '"+STR$(FRE(0))+"'" LET a$(2)="Name des aktuellen Stücks: '"+g_fn$+"'" FOR i|=1 TO g_stka| ! Alle Menüeinträge durch (physikalisch) LET n$(i|)=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Namen festhalten IF g_fn$=n$(i|) ! f Namen gefunden LET j|=i| ! Nummer des gefundenen Namens merken ENDIF ! d NEXT i| ! nächster Menüeintrag LET a$(3)="physikalische Nr. des Stückes: '"+STR$(j|)+"'" QSORT n$() ! Namen alph. sortieren FOR i|=1 TO g_stka| ! Alle Menüeinträge durch (alphabetisch) EXIT IF g_fn$=n$(i|) ! raus f Namen gefunden NEXT i| ! nächster Menüeintrag LET a$(4)="alphabetische Nr. des Stückes: '"+STR$(i|)+"'" @2_t(tn|,ft|,d|,t%) ! Letzte Taktnr. und Nr. des 1.falschen Takts LET a$(5)="Nummer des letzten Taktes:' "+STR$(tn|)+"'" LET a$(6)="Nr. des ersten falschen Taktes: '"+STR$(ft|)+"'" LET a$(7)="1/4 Note dauert: '"+STR$(d|)+"'Zehntelsekunden" LET a$(8)="Dauer des Stücks in Zehntelsek.: '"+STR$(t%)+"'" LET a$(9)="Notenanzahl: '"+STR$(g_mn%)+"'" @2_shwtch(s%,w%,z!) ! Mehr schwarze als weiße Tasten ? LET a$(10)="Anzahl der schwarzen Tasten: '"+STR$(s%)+"'" LET a$(11)="Anzahl der weißen Tasten: '"+STR$(w%)+"'" LET a$(12)="Name des Hauptfiles: '"+g_hf$+"'" ' ............................................................................ ' 2.) I n f o t e x t a n z e i g e n : ' ............................................................................ LET j|=0 ! Inverszähler null FOR i|=1 TO 6 ! Linke Spalte des Infotextes: INC j| ! Zähler fürs Invertieren IF ODD(j|) ! F j| ungerade: PRINT CHR$(27);CHR$(112); ! Invers ein ELSE ! F j| gerade: PRINT CHR$(27);CHR$(113); ! Invers aus ENDIF ! d LET a$=a$(i|) ! Infozeile übergeben LET a$=a$+SPACE$(40-LEN(a$)) ! Infozeile auf Länge von 40 erweitern PRINT AT(1,2+i|);a$; ! Infozeile ausgeben NEXT i| ! nächste Zeile der linken Spalte des Infos LET j|=0 ! Inverszähler null FOR i|=7 TO 12 ! Rechte Spalte des Infotextes: INC j| ! Zähler fürs Invertieren IF EVEN(j|) ! F j| gerade: PRINT CHR$(27);CHR$(113); ! Invers aus ELSE ! F j| ungerade: PRINT CHR$(27);CHR$(112); ! Invers ein ENDIF ! d LET a$=a$(i|) ! Infozeile übergeben LET a$=a$+SPACE$(40-LEN(a$)) ! Infozeile auf Länge von 40 erweitern PRINT AT(41,2+i|-6);a$; ! Infozeile ausgeben NEXT i| ! nächste Zeile der rechten Spalte des Infos PRINT CHR$(27);CHR$(113); ! Invers aus GET 0,18*16,g_bh%-1,g_bb%-1,t$ ! Unteren Textteil fotografieren PUT 0,18*16,t$,8 ! Invers ausgeben ' ............................................................................ ' 3.) W a r t e n a u f T a s t e n d r u c k : ' ............................................................................ REPEAT ! Warteschleife, damit's Bild erst mal bleibt: UNTIL INKEY$="" ! Erst Raus, wenn Puffer leer REPEAT ! Warteschleife PRINT AT(60,1);DATE$;" ";TIME$ ! Datum + Uhrzeit ausgeben UNTIL MOUSEK OR INKEY$<>"" ! Raus, falls Taste gedrückt ' ............................................................................ SPUT b$ ! Bildschirm wiederherstellen ERASE a$() ! Array für Infotext löschen ERASE n$() ! Array für Stücknamen löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_t(VAR tn|,ft|,d|,t%)!_: ' ---------------------------------------------------------------------------- ' Hier wird die Nummer des ersten falschen Taktes, sowie die Nr. des letzten ' Taktes und die Gesamtdauer des Stücks in Zehntelssekunden ermittelt. ' ---------------------------------------------------------------------------- ' ft| ! Nr. des 1. falschen Takts ' tn| ! Taktnummer, am Ende: Nr. des letzten Taktes ' d| ! Dauer einer Viertelnote in Sekunden ' t% ! Zeitmeßvariable ' LOCAL b| ! Periodendauer der akt. Note LOCAL p| ! Betonungsmerker der akt. Note LOCAL i| ! Zähler für Stücknummerermittlung LOCAL i% ! Zähler für Zeitmessung ' ............................................................................ LET tn|=1 ! Mit erstem Takt anfangen FOR i%=1 TO g_mn% ! Alle Noten durch ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LET b|=VAL(MID$(g_n$(i%),2,1))! Periode LET p|=VAL(RIGHT$(g_n$(i%),1))! betont? ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF t%=3*(d|/2) AND p|=1 ! F Taktstrich und 3/8 bisher: LET takt$="3/8" ! 3/8-Takt ist angesagt ELSE IF t%=4*(d|/2) AND p|=1 ! F Taktstrich und 4/8 bisher: LET takt$="4/8" ! 4/8-Takt ist angesagt ENDIF ! EFU 3/8, 4/8 ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF takt$="3/8" AND p|=1 ! F 3/8-Takt und akt. Note mit Taktstrich: IF t%-(tn|-1)*(3*(d|/2))<>3*(d|/2) AND ft|=0 ! F letzter Takt falsch LET ft|=tn| ! Taktnr. des 1.falschen Takts merken ENDIF ! d ELSE IF takt$="4/8" AND p|=1 ! F 4/8-Takt und akt. Note mit Taktstrich: IF t%-(tn|-1)*(4*(d|/2))<>4*(d|/2) AND ft|=0 ! F letzter Takt falsch LET ft|=tn| ! Taktnr. des 1.falschen Takts merken ENDIF ! d ENDIF ! EFU 3/8, 4/8 ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LET t%=t%+d|/(2^b|) ! Notendauer bei 1/4=d sec. ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IF p|=1 ! F Taktstrich: INC tn| ! Taktnummer erhöhen ENDIF ! d ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . NEXT i% ! nächste Note ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_undo !_: ' ---------------------------------------------------------------------------- ' Falls im gu_n$()-Array sich ein Stück befindet, so wird es mit dem Stück im ' g_n$()-Arrray ausgetauscht. ' ............................................................................ IF gu_mn%=0 ! F gar kein Undostück da: GOTO raus_undo ! raus ENDIF ! d ' ............................................................................ SWAP g_mn%,gu_mn% ! Stücklänge des Undostücks wird jetzt aktuell SWAP g_n$(),gu_n$() ! Undostück wird jetzt aktuell SPUT g_lb$ ! Löschbild IF g_mn%=g_os% ! F 200 Noten LET g_n%=g_mn% ! Cursor auf letzte Note ELSE ! sonst: LET g_n%=g_mn%+1 ! Notencursor hinter Stückende ENDIF ! d @2_stueck_ganz_zeigen ! d LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_undo: ! Rauslabel ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 1_write(v|,x%) !_: ' ---------------------------------------------------------------------------- ' Es gibt zwei Möglichkeiten. Entweder der Editor befindet sich im Moment ' im Insertmodus (g_n%<g_mn%+1) oder im Endschreibmodus (g_n%=g_mn%+1). Ent- ' sprechend wird dann in die jeweiligen Unterprozeduren verzweigt. ' ............................................................................ ' v| ! Minuszweioktavenflag gesetzt ? ' x% ! Koordinate der Maus auf der Klaviatur ' ---------------------------------------------------------------------------- IF g_bla%=0 AND g_ble%=0 ! Nur schreiben, wenn keine Blockmarken existieren IF g_n%<g_mn%+1 ! F nicht Endschreibmodus, also Insertmodus @2_insert(v|,x%) ! d ELSE ! F Endschreibmodus @2_endeschr(v|,x%) ! d ENDIF ! EFU Insertmodus / Endschreibmodus ENDIF ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_endeschr(v|,x%) !_: ' ---------------------------------------------------------------------------- ' Diese Prozedur wird im Endschreibmodus aufgerufen und sorgt dafür, daß die ' durch eine Klaviaturtaste vom Benutzer bereits festgelegte Note hinten am ' Notentextende angefügt wird. ' ---------------------------------------------------------------------------- ' v| ! Minuszweioktavenflag gesetzt ? ' x% ! Koordinate der Maus auf der Klaviatur LOCAL f! ! Fehlerflag für Tonausgabe LOCAL h| ! Notentastennummer ' ............................................................................ IF g_mn%>=g_os% ! F Nummer der letzten Note >=obere Schranke GOTO raus_endeschreiben ! d ENDIF ! d ' ............................................................................ IF x%<g_ptb| OR x%>g_bb%-g_ptb| ! Pausentaste ? LET h|=26 ! Pausencode ELSE ! Notentaste: LET h|=TRUNC((x%-g_ptb|)/g_ntb|)+1! Notentaste feststellen ENDIF ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus PUT g_x%(g_n%),g_y%(g_n%),g_nb$(h|,1,v|,0),7 ! Note auf Bildschirm LET g_n$(g_n%)=CHR$(64+h|)+"1"+STR$(v|)+"0" ! Note abspeichern LET g_proctest$="endeschr" ! Name der aufrufenden Prozedur fürDebugging IF NOT g_midi! ! F kein Midi-Gerät angeschlossen @a_tonausgabe(f!) ! d ENDIF ! endif IF g_n%<g_os% ! F akt. Notennummer < obere Schranke INC g_n% ! Notennummer=Cursorposition erhöhen ENDIF ! d INC g_mn% ! Nummer der letzten Note erhöhen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_endeschreiben: ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_insert(v|,x%) !_: ' ---------------------------------------------------------------------------- ' Bei Aufruf dieser Prozedur befindet sich der Editor momentan im Insert- ' modus, das heißt der Cursor steht nicht ganz am Notentextende auf dem Leer- ' platz hinter der letzten Note, sondern a u f irgendeiner Note. Dann wird ' die gewünschte, durch eine Klaviaturtaste vom Benutzer bereits festge- ' legte Note vor der Cursorposition im Notentext eingefügt. ' ---------------------------------------------------------------------------- ' v| ! Vierteltonflag gesetzt ? ' x% ! Koordinate der Maus auf der Klaviatur LOCAL f! ! Fehlerflag für Tonausgabe LOCAL h| ! Notentastennummer ' ............................................................................ IF g_mn%>=g_os% ! F Notenendnr>= maximale obere Schranke GOTO raus_insert ! Prozedur unverrichteter Dinge verlassen ENDIF ! d ' ............................................................................ IF x%<g_ptb| OR x%>g_bb%-g_ptb| ! Pausentaste ? LET h|=26 ! Pausencode ELSE ! Notentaste: LET h|=TRUNC((x%-g_ptb|)/g_ntb|)+1! Notentaste feststellen ENDIF ! d ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus ' ............................................................................ ' ! Note im Notenspeicherstring einfügen: INSERT g_n$(g_n%)=CHR$(64+h|)+"1"+STR$(v|)+"0" INC g_mn% ! Nummer der letzten Note erhöhen @3_grafikinsert ! alles hinter & einschl.Cursor 1 weiter ' ............................................................................ LET g_proctest$="insert" ! Name der aufrufenden Prozedur fürDebugging IF NOT g_midi! ! F kein Midi-Gerät angeschlossen @a_tonausgabe(f!) ! d ENDIF ! endif ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_nb$(h|,1,v|,0),7 ! Note auf Bildschirm ' ............................................................................ INC g_n% ! Notennummer=Cursorposition erhöhen ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_insert: ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_grafikinsert !_: ' ---------------------------------------------------------------------------- ' In dieser Prozedur wird vor der akt. Cursorposition ein Leerplatz einge- ' fügt und alles, was dahinter ist, um eins weiter nach rechts gerückt. ' Achtung! : Insert im Speicherarray v o r Aufruf dieser Prozedur !! Das ' gilt auch für die Aktualisierung der letzten Notennummer: g_mn% !! ' Genauer: ' 1.) Erst wird in der aktuellen Zeile, in der sich der Cursor befindet, alles ' rechts vom Cursor einschließlich der Note auf der Cursorposition fotogra- ' fiert und eine Position weiter rechts wieder ausgegeben. ' Nun wir die Cursornote der aktuellen Zeile, die ja jetzt doppelt vorhanden ' ist, gelöscht und stattdessen ein Leerplatz dort ausgegeben. ' 2.) Dann werden alle Zeilen unterhalb der aktuellen Zeile auf einmal foto- ' grafiert und zwar so, daß rechts eine eine Note breite Spalte bleibt. Dieser ' Zeilenblock wird dann eine Position weiter rechts wieder ausgegeben. ' Nun wird die äußerst linke Notenspalte, die ja jetzt doppelt vorhanden ist, ' in einer FOR-NEXT-Schleife gelöscht und in derselben Schleife stattdessen ' die entsprechenden ersten Noten der jeweiligen Zeilen dort ausgegeben. ' ---------------------------------------------------------------------------- LOCAL i| ! Zeilenzähler physikalisch LOCAL j| ! Zeilenzähler logisch LOCAL aktz| ! Aktuelle Zeile LOCAL x1% ! links LOCAL x2% ! rechts LOCAL y1% ! oben LOCAL y2% ! unten LOCAL x% ! x-Koordinate nach dem Verschieben LOCAL lnr% ! Linkenotennr: Notennr. der Note am link. Rand LOCAL n% ! irgendeine Note in der letzten Zeile ' ............................................................................ LET aktz|=TRUNC((g_n%-1)/g_npz|)+1! Akt.Zeile=tr.(akt.Note-1/Noten proZeile)+1 ' ............................................................................ ' 1.) ! Jetzt die aktuelle Zeile (siehe auch Bild): ' ............................................................................ LET x1%=g_x%(g_n%) ! links LET x2%=g_bb%-g_nb| ! rechts LET y1%=g_y%(g_n%) ! oben LET y2%=y1%+g_nzlh|-1 ! unten: oben + Notenzeilenhöhe - 1 GET x1%,y1%,x2%,y2%,a$ ! Alles rechts vom Cursor (einschl.) fotograf. LET x%=x1%+g_nb| ! Neuer Wert links: um 1 Notenpos. weiter rechts PUT x%,y1%,a$ ! Fotografierte Notenzeile 1 weiter recht ausgeb PUT x1%,y1%,g_lz$ ! Leerzeichen an Cursorposition ausgeben ' ............................................................................ IF g_mn%<=aktz|*g_npz| ! F Endnote <= letzte Note in aktueller Zeile GOTO raus_grafikinsert ! raus,eigentlich müßte das die FOR-Schleife tun ENDIF ! d ' ............................................................................ ' 2.) ! Jetzt die Zeilen unter der akt. (s.a. Bild): ' ............................................................................ LET x1%=0 ! Neue Linkskoordinate, Rechtsk. bleibt gleich LET y1%=g_y%((aktz|*g_npz|)+1)! oben y-Wert: (akt.Zeile*Zeilennot.anz) + 1 LET y2%=g_bh%-1 ! unten: Bildschirmhöhe - 1 GET x1%,y1%,x2%,y2%,a$ ! i|-te Notenzeile fotograf. außer Note rechts LET x%=x1%+g_nb| ! Wert links: um eine Notenpos.weiter rechts PUT x%,y1%,a$ ! Fotografierte Notenzeile 1 weiter recht ausgeb FOR i|=aktz| TO g_za| ! Alle Zeilen unterhalb akt. Zeile(einschl)durch LET lnr%=i|*g_npz|+1 ! linke Note der i|-ten Zeile berr: ' ! Notenanzahl pro Zeile * Term analog aktz| EXIT IF lnr%>g_mn% ! raus, falls in der aktuellen Zeile nix mehr is LET a|=ASC(LEFT$(g_n$(lnr%),1))-64 ! linke Note der i|-ten Zeile: Tonhöhe LET b|=VAL(MID$(g_n$(lnr%),2,1)) ! linke Note der i|-ten Zeile: Periode LET c|=VAL(MID$(g_n$(lnr%),3,1)) ! linke Note der i|-ten Zeile: gebund.? LET d|=VAL(RIGHT$(g_n$(lnr%),1)) ! linke Note der i|-ten Zeile: betont? PUT g_x%(lnr%),g_y%(lnr%),g_lz$ ! In i|-ter Zle in 1.Spalte: Leerzeichen PUT g_x%(lnr%),g_y%(lnr%),g_nb$(a|,b|,c|,d|),7 ! linke Note der i|-ten ' ! Zeile in i|-ter Zeile in 1. Spalte ausgeben NEXT i| ! nächste Zeile unterhalb akt. Zeile ' ............................................................................ raus_grafikinsert: ! Rauslabel ' ............................................................................ ' Originaler Text: Text mit inserted space vor (s): ' ' aktuelle Zeile q r(s)t u q r _ s t ' . . u . ' . . . ' . . x . ' i|-1 te Zeile: a b c d e x a b c d ' i| te Zeile: f g h i j e f g h i ' i|+1 te Zeile: k l m n o j k l m n ' . . o . ' . . . ' . . . ' i| te Zeile: f g h i j e f g h i ' |_____| ---> |_____| ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_neu_cpos(x%,y%) !_: ' ---------------------------------------------------------------------------- ' Hier wird die neue gewünschte Cursorposition ermittelt und der Cursor ' entsprechend neu positioniert. ' ---------------------------------------------------------------------------- LOCAL n% ! vorläufige Notennr LOCAL f! ! Fehlerflag für Tonausgabe ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus @3_notenr(x%,y%,n%) ! Welche Note liegt unter dem Mauspfeil? IF n%>=g_mn%+1 ! F vorl.Notennr > letzte Notennr + 1: Endschreibmodus: ' ! d.h. der Cursor wird dann hinter der letzten Note sein LET g_n%=g_mn%+1 ! vorläufige Notennummer an entgültige Globalvar übergeb ELSE ! F es beim Insertmodus bleibt LET g_n%=n% ! vorläufige Notennummer an entgültige Globalvar übergeb LET g_proctest$="neu_cpos" ! Name der aufrufenden Prozedur fürDebugging @a_tonausgabe(f!) ! geht eben nur f Note da, dh. g_n%<=g_mn% ENDIF ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_takt_setzen !_: ' ---------------------------------------------------------------------------- ' Es werden bei der aktuellen Note unter dem Cursor ein Taktstrich gesetzt ' bzw. gelöscht (wenn vorher schon einer da war.). ' ---------------------------------------------------------------------------- LOCAL a| ! Tonhöhe LOCAL b| ! Periodendauer LOCAL c| ! - 2 Oktaven ? LOCAL d| ! Taktstrich ? LOCAL i| ! Zähler für die 4 Kombinationsmöglichk. ' ............................................................................ IF g_bla%<>0 OR g_ble%<>0 ! F Blockmarken existieren: GOTO raus_takt_setzen ! Raus ENDIF ! d IF g_n%>g_mn% ! F Endschreibmodus: GOTO raus_takt_setzen ! Raus ENDIF ! d IF ASC(LEFT$(g_n$(g_n%),1))-64<0 ! F kaputte Tonhöhe GOTO raus_takt_setzen ! Raus ENDIF ! d ' ............................................................................ LET a|=ASC(LEFT$(g_n$(g_n%),1))-64 ! Tonhöhe LET b|=VAL(MID$(g_n$(g_n%),2,1)) ! Periode LET c|=VAL(MID$(g_n$(g_n%),3,1)) ! - 2 Oktaven? LET d|=VAL(RIGHT$(g_n$(g_n%),1)) ! Taktstrich? ' ............................................................................ IF d|=1 ! F Taktstrich gesetzt: LET d|=0 ! Taktstrich löschen ELSE ! F Taktstrich nicht gesetzt: LET d|=1 ! Taktstrich setzen ENDIF ! d ' ............................................................................ MID$(g_n$(g_n%),4,1)=STR$(d|) ! Änderung abspeichern PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus PUT g_x%(g_n%),g_y%(g_n%),g_lz$ ! Leerzeichen an Cursorposition ausgeben PUT g_x%(g_n%),g_y%(g_n%),g_nb$(a|,b|,c|,d|),7 ! Note auf Bildschirm PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_takt_setzen: ! Raus ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_notenr(x%,y%,VAR n%)!_: ' ---------------------------------------------------------------------------- ' Hier wird ermittelt, welchen Koordinaten x% und y% welche Notennummer auf ' dem Bildschirm entsprechen. ' ---------------------------------------------------------------------------- LOCAL aktz| ! Aktuelle Zeile LOCAL aktsp| ! Aktuelle Spalte ' ............................................................................ LET aktz|=TRUNC((y%-g_mh|)/g_nzlh|)+1 ! Aktuelle Zeile berechnen: ' ! [(y%-Menühöhe)/Notenzeilenhöhe]+1 LET aktsp|=TRUNC(x%/g_nb|)+1 ! Aktuelle Spalte berechnen: ' ! [x%/Notenbreite]+1 LET n%=aktsp|+(aktz|-1)*g_npz| ! Aktuelle Notennummer berechnen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_nur_ton(v|,x%) !_: ' ---------------------------------------------------------------------------- ' Hier wird nur getönt, nichts gespeichert und nichts gezeichnet. ' ---------------------------------------------------------------------------- LOCAL t| ! Notentastennummer ' ............................................................................ LET t|=TRUNC((x%-g_ptb|)/g_ntb|)+1! Notentaste feststellen @a2_s(g_ls|,t|,v|,10) ! Tonausgabe ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_backspace !_: ' ---------------------------------------------------------------------------- ' Hier wird die Note vor dem Cursor gelöscht, also nicht die unter ihm. ' ---------------------------------------------------------------------------- IF g_bla%<>0 OR g_ble%<>0 OR g_n%=1! Nur Backspace,f keine Blockmarken&>1.Note GOTO raus_backspace ! Prozedur unverrichteter Dinge verlassen ENDIF ! d ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus ' ............................................................................ IF g_n%=g_mn%+1 ! F Endschreibmodus eingeschaltet: DELETE g_n$(g_n%) ! Note bei Cursorpos.imNotenspeicher löschen PUT g_x%(g_mn%),g_y%(g_mn%),g_lz$! Leerzeichen 1 vor Cursorposition ausgeben DEC g_mn% ! Nummer der letzten Note erniedrigen ELSE ! F Insertmodus eingeschaltet: DELETE g_n$(g_n%-1) ! Note vor Cursorpos.imNotenspeicher löschen DEC g_mn% ! Nummer der letzten Note erniedrigen @2_grafikdelete ! alles hinter & einschl.Cursor 1 zurück ENDIF ! EFU Endschreibmodus / Insertmodus ' ............................................................................ DEC g_n% ! Notennummer=Cursorposition erniedrigen ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_backspace: ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_grafikdelete !_: ' ---------------------------------------------------------------------------- ' In dieser Prozedur wird die Note vor der aktuellen Cursorposition gelöscht, ' d.h. alle Noten rechts vom Cursor, einschließlich der Note auf dem Cursor ' werden um eine Stelle nach links gerückt. ' Genauer: ' 1.) Erst wird in der aktuellen Zeile, in der sich der Cursor befindet, alles ' rechts vom Cursor einschließlich der Note auf der Cursorposition fotogra- ' fiert und eine Position weiter links wieder ausgegeben. ' 2.) Dann werden alle Zeilen unterhalb der aktuellen Zeile auf einmal foto- ' grafiert und zwar so, daß links eine eine Note breite Spalte bleibt. Dieser ' Zeilenblock wird dann eine Position weiter links wieder ausgegeben. ' Nun wird die äußerst rechte Notenspalte, die ja jetzt doppelt vorhanden ist, ' in einer FOR-NEXT-Schleife gelöscht und in derselben Schleife stattdessen ' die entsprechenden letzten Noten der jeweiligen Zeilen dort ausgegeben. D.h. ' Delete muß im Speicherstringarray bereits v o r Aufruf dieser Prozedur ' hier stattgefunden haben !! Das gilt auch für die Endnotennummer g_mn% !!! ' ---------------------------------------------------------------------------- LOCAL i| ! Zeilenzähler physikalisch LOCAL j| ! Zeilenzähler logisch LOCAL aktz| ! Aktuelle Zeile LOCAL x1% ! links LOCAL x2% ! rechts LOCAL y1% ! oben LOCAL y2% ! unten LOCAL x% ! x-Koordinate nach dem Verschieben LOCAL enr% ! Linksnotennr: Notennr. der Note am rechtenRand LOCAL n% ! irgendeine Note in der nächsten Zeile ' ............................................................................ LET aktz|=TRUNC((g_n%-1)/g_npz|)+1! Akt.Zeile=tr.(akt.Note-1/Noten proZeile)+1 ' ............................................................................ ' 1.) ! Jetzt die aktuelle Zeile (siehe auch Bild): ' ............................................................................ LET x1%=g_x%(g_n%) ! links LET x2%=g_bb%-1 ! rechts=rechter Bildschirmrand LET y1%=g_y%(g_n%) ! oben LET y2%=y1%+g_nzlh|-1 ! unten: oben + Notenzeilenhöhe - 1 IF g_n%-1+g_npz|=aktz|*g_npz| ! F Cursor auf 1. Spalte: DEC aktz| ! Bei 2.) 1 Zeile früher anfangen ELSE ! F Cursor nicht auf 1. Spalte: GET x1%,y1%,x2%,y2%,a$ ! Alles rechts vom Cursor (einschl.) fotograf. LET x%=x1%-g_nb| ! Neuer Wert links: um 1 Notenpos. links zurück PUT x%,y1%,a$ ! Fotografierte Notenzeile 1 weiter links ausgeb ENDIF ! EFU Cursor auf / nicht auf 1. Spalte ' ............................................................................ IF g_mn%<aktz|*g_npz| ! F Endnote < letzte Note in aktueller Zeile ' ! Warum nicht <= ? Weil im Speicherstringarray ' ! bereits Delete gemacht wurde und Gleichheit ' ! somit bedeutet, daß vor Backspace nicht die ' ! Gleichheit galt, sondern g_mn%=aktz|*g_npz|+1! ' ! Dh. in der unteren Zeile war noch eine Note ' ! und die muß ja auch noch gelöscht werden, die ' ! IF-Bedingung darf also nicht erfüllt sein. PUT x2%-g_nb|,y1%,g_lz$ ! Leerzeichen am rechten Zeilenrand ausgeben GOTO raus_grafikdelete ! Prozedur verlassen ENDIF ! EF Endnote <= letzte Note in aktueller Zeile ' ............................................................................ ' 2.) ! Jetzt die Zeilen unter der akt. (s.a. Bild): ' ............................................................................ LET x1%=g_nb| ! Neue Linkskoordinate, Rechtsk. bleibt gleich LET y1%=g_y%((aktz|*g_npz|)+1)! oben y-Wert: (akt.Zeile*Zeilennot.anz) + 1 LET x2%=g_bb%-1 ! rechts=rechter Bildschirmrand LET y2%=g_bh%-1 ! unten: Bildschirmhöhe - 1 GET x1%,y1%,x2%,y2%,a$ ! Notenzeilenblock fotograf. außer Note rechts LET x%=0 ! Neuer wert links: Notenzeilenanfang PUT x%,y1%,a$ ! Fotografierter Zeilenblock1 weiter links ausg ' .......................................................................... FOR i|=aktz| TO g_za| ! Zeilen unterhalb akt. Zeile (einschl.) durch ' .......................................................................... LET enr%=i|*g_npz| ! Endnotennr der i|-ten Zeile berr: ' ! Aktuelle Zeile * Notenanzahl pro Zeile EXIT IF enr%>g_mn% ! Raus f Endnotennr > Nr. letzter Note LET a|=ASC(LEFT$(g_n$(enr%),1))-64 ! Endnote d. i|-ten Zle: Tonhöhe LET b|=VAL(MID$(g_n$(enr%),2,1)) ! Endnote d. i|-ten Zle: Periode LET c|=VAL(MID$(g_n$(enr%),3,1)) ! Endnote d. i|-ten Zle: gebund.? LET d|=VAL(RIGHT$(g_n$(enr%),1)) ! Endnote d. i|-ten Zle: betont? LET y1%=g_y%(enr%) ! oben y-Wert der Endnote PUT x2%-g_nb|,y1%,g_lz$ ! Leerzeichen am rechten Zeilenrand ausgeben PUT g_x%(enr%),g_y%(enr%),g_nb$(a|,b|,c|,d|),7 ! Endnote d.i|-ten Zle ' ! in akt. Zeile an letzter Stelle ausgeben ' .......................................................................... NEXT i| ! nächste Zeile unterhalb akt. Zeile PUT x2%-g_nb|,g_y%(enr%),g_lz$ ! Leerzeichen am rechten Zeilenrand ausgeben raus_grafikdelete: ! Rauslabel ' ............................................................................ ' Originaler Text: Text nach delete von r ' ' aktuelle Zeile q r(s)t u q(s)t u v ' . v . . ' . . . ' . . . a ' i|-1 te Zeile: a b c d e b c d e f ' i| te Zeile: f g h i j g h i j k ' i|+1 te Zeile: k l m n o l m n o p ' . p . . ' . . . ' . . . ' i| te Zeile: f g h i j g h i j k ' |_____| ---> |_____| ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_spielen(x%,y%) !_: ' ---------------------------------------------------------------------------- ' Führ den Befehl der rechten Maustaste (ohne Alternate-Taste) aus: Von ' der Note unter dem Mauspfeil bis zur Note unterhalb des Cursors soll ge- ' spielt werden, bzw. umgekehrt, falls eine Note hinter dem Cursor ange- ' klickt wurde. ' ---------------------------------------------------------------------------- LOCAL q| ! Startnote LOCAL r| ! Endnote LOCAL n% ! vorläufige Notennr ' ............................................................................ @3_notenr(x%,y%,n%) ! Welche Note liegt unter dem Mauspfeil? ' ............................................................................ IF n%>g_mn% ! F vorl.Notennr > letzte Notennr: GOTO raus_spielen ! Spielen zwecklos, raus! ENDIF ! d IF n%>g_n% ! F Mauspfeilnote > Cursornote LET q|=g_n% ! Startnote = Cursornote LET r|=n% ! Endnote = Mauspfeilnote ELSE ! F Mauspfeilnote <= Cursornote LET q|=n% ! Startnote = Mauspfeilnote LET r|=g_n% ! Endnote = Cursornote ENDIF ! EFU Mauspfeilnote > / <= Cursornote IF q|>g_mn% ! F Start > letzte existierende Note LET q|=g_mn% ! setze Startnote = letzte existierende Note ENDIF ! d IF r|>g_mn% ! F Endnote > letzte existierende Note LET r|=g_mn% ! setze Endnote = letzte existierende Note ENDIF ! d ' ............................................................................ @2_abspielen(q|,r|) ! Von Note q| bis Note r| spielen ' ............................................................................ raus_spielen: ! Rauslabel ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_abspielen(q|,r|) !_: ' ---------------------------------------------------------------------------- ' Hier wird von der Note q| bis zur Note r| gespielt. ' ---------------------------------------------------------------------------- LOCAL f! ! Fehlerflag für Tonausgabe LOCAL dw! ! Dauerwiederholvorgabe LOCAL b| ! Periodendauer LOCAL mg_n% ! Merker für Cursorposition LOCAL k% ! Tastencode ' ............................................................................ @3_soundwahl ! Sound bei Midi-Keyboard einstellen LET b|=VAL(MID$(g_n$(g_mn%),2,1)) ! Periode der letzten Note IF b|=3 AND g_mn%>3 AND g_mn%-r|<3 ! F letzte Note 1/32 und > 3 Noten da: LET r|=r|-2 ! Soundmarkierungen beim Abspielen weglassen ENDIF ! d ' ............................................................................ LET mg_n%=g_n% ! Cursorposition merken ' ............................................................................ REPEAT ! Warteschleife für Mauseingabe: UNTIL MOUSEK=0 ! Erst Raus,wenn Maus nix mehr meldet,also Puffer leer ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus ' ............................................................................ REPEAT ! Dauerwiederholschleife ' .......................................................................... FOR g_n%=q| TO r| ! Alle zu spielenden Noten durch ' ........................................................................ IF MOUSEK=2 ! F rechte Maustaste LET dw!=TRUE ! Dauerwiederholvorgabe einschalten ENDIF ! d ' ........................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ........................................................................ KEYLOOK k% ! gedrückte Taste anschauen IF MOUSEK=1 OR k%=65563 OR k%=268501019 ! F linke Maustaste; oft Abbruchm. PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus LET dw!=FALSE ! Dauerwiederholungsvorgabe=Falsch EXIT IF -1 ! raus ENDIF ! d ' ........................................................................ LET g_proctest$="abspielen" ! Name der aufrufenden Prozedur fürDebugging ' ........................................................................ IF MOUSEK=1 ! F linke Maustaste; oft Abbruchm. PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus LET dw!=FALSE ! Dauerwiederholungsvorgabe=Falsch EXIT IF -1 ! raus ENDIF ! d ' ........................................................................ LET f!=FALSE ! Fehlerflag erst mal 0 (dh. alles ok!) @a_tonausgabe(f!) ! d IF f! ! f Fehlerflag gesetzt PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus LET dw!=FALSE ! Dauerwiederholungsvorgabe=Falsch EXIT IF -1 ! raus ENDIF ! d ' ........................................................................ IF MOUSEK=1 ! F linke Maustaste; oft Abbruchm. PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus LET dw!=FALSE ! Dauerwiederholungsvorgabe=Falsch EXIT IF -1 ! raus ENDIF ! d ' ........................................................................ PAUSE g_vz|/2^VAL(MID$(g_n$(g_n%),2,1))! Pause Abspielgeschw./2^Fähnchenzahl ' ........................................................................ IF MOUSEK=1 ! F linke Maustaste; oft Abbruchm. PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus LET dw!=FALSE ! Dauerwiederholungsvorgabe=Falsch EXIT IF -1 ! raus ENDIF ! d ' ........................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus ' ........................................................................ NEXT g_n% ! nächste zu spielende Note ' .......................................................................... UNTIL dw!=FALSE ! wiederhole bis abgebrochen WAVE 0,0 ! Ton aus ' ............................................................................ LET g_n%=mg_n% ! Cursorposition wiederherstellen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_soundwahl !_: ' ---------------------------------------------------------------------------- ' (*): Wenn die letzte Note im Stück eine 1/32- Note ist, wird ' ............................................................................ LOCAL al| ! Tonhöhe der letzten Note LOCAL av| ! Tonhöhe der vorletzten Note LOCAL b| ! Periodendauer LOCAL s1% ! Soundparameter LOCAL s2% ! Soundparameter LOCAL s3% ! Soundparameter ' ............................................................................ LET b|=VAL(MID$(g_n$(g_mn%),2,1)) ! Periode der letzten Note IF b|=3 AND g_midi!=TRUE AND g_mn%>3 ! F letzte Note 1/32 und Midi ein: LET s1%=ASC(LEFT$(g_n$(g_mn%-1),1))-65! Tonhöhe der vorletzen Note LET s2%=ASC(LEFT$(g_n$(g_mn%),1))-65! Tonhöhe der letzten Note ' PRINT AT(1,1);"'";s1%;"'","'";s2%;"' " OUT 3,192,s1% ! Sound einschalten Kanal 1 OUT 3,193,s2% ! Sound einschalten Kanal 2 ENDIF ! d OUT 3,194,g_k3| ! immer Percussion-Sound auf Kanal 3 ' ............................................................................ ' (*): Die Vorletzte Note bildet die 1. Ziffer des Soundparameters, die ' letzte Note (genauer: die Tonhöhe der letzten Note) die 2. Ziffer. ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_faehnchen !_: ' ---------------------------------------------------------------------------- ' Der aktuellen Note wird ein Fähnchen hinzugefügt. Ist die Fähnchenobergrenze ' bereits erreicht, fängt's wieder bei null Fähnchen an. ' ---------------------------------------------------------------------------- LOCAL a| ! Tonhöhe LOCAL b| ! Periodendauer LOCAL c| ! gebunden? LOCAL d| ! betont? ' ............................................................................ IF g_bla%<>0 OR g_ble%<>0 ! F Blockmarken existieren: GOTO raus_faehnchen ! Raus ENDIF ! d IF g_n%>g_mn% ! F Endschreibmodus: GOTO raus_faehnchen ! Raus ENDIF ! d IF ASC(LEFT$(g_n$(g_n%),1))-64<0 ! F kaputte Tonhöhe GOTO raus_takt_setzen ! Raus ENDIF ! d ' ............................................................................ LET a|=ASC(LEFT$(g_n$(g_n%),1))-64 ! letzte Note d.vorherigen Zle: Tonhöhe LET b|=VAL(MID$(g_n$(g_n%),2,1)) ! letzte Note d.vorherigen Zle: Periode LET c|=VAL(MID$(g_n$(g_n%),3,1)) ! letzte Note d.vorherigen Zle: gebund.? LET d|=VAL(RIGHT$(g_n$(g_n%),1)) ! letzte Note d.vorherigen Zle: betont? ' ............................................................................ IF b|=3 ! F maximale Fähnchenanzahl: LET b|=0 ! Fähnchenanzahl null ELSE ! < maximale Fähnchenanzahl: INC b| ! ein Fähnchen dazu ENDIF ! d MID$(g_n$(g_n%),2,1)=STR$(b|) ! Änderung abspeichern PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus PUT g_x%(g_n%),g_y%(g_n%),g_lz$ ! Leerzeichen an Cursorposition ausgeben PUT g_x%(g_n%),g_y%(g_n%),g_nb$(a|,b|,c|,d|),7 ! Note auf Bildschirm PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_faehnchen: ! d ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE a_tonausgabe(f!) !_: ' ---------------------------------------------------------------------------- ' Aufrufende Prozeduren: 'endeschr', 'insert', 'neu_cpos', 'abspielen' ' ---------------------------------------------------------------------------- ' f! ! Fehlerflag LOCAL m| ! Wahldummy für Alertbox LOCAL a| ! Tonhöhe LOCAL b| ! Periodendauer LOCAL c| ! - 2 Oktaven? LOCAL d| ! Taktstrich ? LOCAL m$ ! Menütextvariable ' ............................................................................ IF ASC(LEFT$(g_n$(g_n%),1))-64<0 ! F Katastrophe (Stück kaputt!!) LET m$="Achtung! Fehler|in 'a_tonausgabe'|bei Notennr:'" LET m$=m$+STR$(g_n%)+"'|Stück '"+g_fn$+"'ist futsch! /raus!" @a_alert(m$,m|) ! d LET f!=TRUE ! Fehlerflag setzen GOTO raus_tonausgabe ! unverrichteter Dinge raus ENDIF ! d ' ............................................................................ LET a|=ASC(LEFT$(g_n$(g_n%),1))-64 ! Tonhöhe LET b|=VAL(MID$(g_n$(g_n%),2,1)) ! Periode LET c|=VAL(MID$(g_n$(g_n%),3,1)) ! - 2 Oktaven? LET d|=VAL(RIGHT$(g_n$(g_n%),1)) ! betont, also mit Taktstrich? ' ............................................................................ IF g_n%>1 ! F Notennr. > 1 WAVE 0,0 ! Ton aus PAUSE 1 ! Kurze Pause ENDIF ! d ' ............................................................................ @a2_s(g_ls|+d|*2,a|,c|,b|) ! entgültige Tonausgabe ' PAUSE g_vz|/2^b| ! Pause Abspielgeschw./2^Fähnchenzahl raus_tonausgabe: ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a2_s(ls|,th|,ok|,zt|) !_: ' ---------------------------------------------------------------------------- ' ls| ! Lautstärke ' th| ! Tonhöhe ' ok| ! - 2 Oktaven? ' zt| ! Zeit (Dauer der Note) LOCAL oktave| ! Oktavenvariable ' ............................................................................ IF th|=26 ! F Pause IF NOT g_midi! ! F kein Midi-Keyboard angeschlossen: WAVE 0,0 ! Ton aus ELSE ! F Midi-Keyboard angeschlossen OUT 3,128,g_mt1|,1 ! alten Ton aus Kanal 1 OUT 3,128,g_mt1|-24,1 ! alten Taktstrichton aus Kanal 1 OUT 3,129,g_mt2|,1 ! alten Ton aus Kanal 2 OUT 3,130,g_perc| ! alten Ton aus Kanal 3 IF ls|>g_ls| ! F Taktstrich OUT 3,146,g_perc|,1 ! neuen Ton an Kanal 3 ENDIF ! d ENDIF ! d ELSE ! keine Pause IF NOT g_midi! ! F kein Midi-Keyboard angeschlossen: ' Folgender Befehl ist für Vierteltonmusik gedacht:siehe auch '1_tonhoehe' ' Hier klappt's nur mit 2 Oktaven, also nicht jetzt, da 4 Oktaven erlaubt. ' SOUND 1,ls|,#(ROUND(125000/fr%(th|+vt|*25))),zt| ! endgültige Tonausgabe SOUND 1,ls|,th|,g_okt|-2*ok|,zt| ! jetzige Tonausgabe ELSE ! F Midi-Keyboard angeschlossen OUT 3,128,g_mt1|,1 ! alten Ton aus Kanal 1 OUT 3,129,g_mt2|,1 ! alten Ton aus Kanal 2 OUT 3,130,g_perc| ! alten Ton aus Kanal 3 ' LET oktave|=59-24*ok| ! F Minuszweioktavenflag gesetzt: ' ! eben 2 Oktaven abziehen LET g_mt1|=oktave|+th| ! Ton merken OUT 3,144,g_mt1|,1 ! neuen Ton an Kanal 1 LET g_mt2|=oktave|+th| ! Ton merken IF ok|=0 ! F nicht minus 2 Oktaven LET g_mt2|=g_mt2|-24 ! 2 Oktaven abziehen ENDIF ! d OUT 3,145,g_mt2|,1 ! neuen Ton an Kanal 2 IF ls|>g_ls| ! F Taktstrich OUT 3,146,g_perc|,1 ! neuen Ton an Kanal 3 ENDIF ! d ENDIF ! d ENDIF ! EFU Pause / keine Pause ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_undostueck !_: ' ---------------------------------------------------------------------------- ' Hier wird das aktuelle Stück in den Undo-Array kopiert ' ............................................................................ LOCAL i% ! Notenzähler ' ............................................................................ LET gu_mn%=g_mn% ! Stücklänge speichern FOR i%=1 TO g_mn% ! ganzes Stück durch LET gu_n$(i%)=g_n$(i%) ! Note kopieren NEXT i% ! nächste Note ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_fehler_abfangen !_: ' ---------------------------------------------------------------------------- ' Im Falle daß ein Fehler im Programmablauf auftaucht, wird wegen des aller- ' ersten Befehls des Programms 'on error gosub a_fehler_abfangen' hierher- ' gesprungen. So kann dann der Text erst einmal gerettet werden: ' ---------------------------------------------------------------------------- @a_alert("Fehler im Programm!/Abspeichern!",a|) @2_stueck_abspeichern ! Text schnell noch mal abspeichern PRINT CHR$(7); ! klingeln PRINT AT(1,1);ERR$(ERR);" Fatal=";FATAL PRINT AT(3,3);"letzte notierte Prozedur: '";g_proctest$;"'" STOP ! d ' ---------------------------------------------------------------------------- RETURN ' ############################################################################## ' S t ü c k b e a r b e i t u n g : ' ############################################################################## > PROCEDURE 0_hauptmenue !_: ' ---------------------------------------------------------------------------- LOCAL i| ! Zähler für Menüeinträge LOCAL m| ! Maustastenmerker LOCAL a| ! Nr. des gewählten Menüeintrags DIM h$(10) ! Hauptmenüeintragsliste DIM d!(10) ! Dummyarray ' ............................................................................ IF NOT g_midi! ! F kein Midi-Keyboard angeschlossen: WAVE 0,0 ! Ton aus ELSE ! F Midi-Keyboard angeschlossen OUT 3,128,g_mt1|,1 ! alten Ton aus Kanal 1 OUT 3,128,g_mt1|-24,1 ! alten Taktstrichton aus Kanal 1 OUT 3,129,g_mt2|,1 ! alten Ton aus Kanal 2 OUT 3,130,g_perc|,1 ! alten Ton aus Kanal 3 ENDIF ! d ' ............................................................................ RESTORE hauptmenue ! Readzeiger auf Position REPEAT ! Leseschleife INC i| ! Eintragszähler erhöhen READ h$(i|) ! Hauptmenüeintrag lesen UNTIL h$(i|)="##" ! Raus f nix eingelesen DEC i| ! Anzahl der Hauptmenüeinträge ' ............................................................................ nochmal_hauptmenue: ! d PRINT AT(1,1);SPACE$(80); ! 1. Zeile ganz weiß (sieht besser aus) PUT 56*8,0,g_prgname$ ! Programmnamen abbilden @a_menue(-1,0,-1,0,0,0,1,0,i|,1,m|,a|,h$(),d!()) IF a|=0 ! F Abbruch: GOTO raus_hauptmenue ! d ENDIF ! d @1_um(a|,m|) ! Untermenü ausfahren IF a|<>i| OR m|=2 ! F nicht letzten Eintrag gewählt: GOTO nochmal_hauptmenue ! d ENDIF ! d ' ............................................................................ raus_hauptmenue: ! d ERASE h$(),d!() ! Arrays löschen PUT 0,0,g_kl$ ! Klaviatur wiederherstellen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_um(w|,VAR m|) !_: ' ---------------------------------------------------------------------------- ' w| ! Nr des gewählten Eintrags im Hauptmenü ' m| ! Maustaste LOCAL i| ! Zähler für Menüeinträge LOCAL q| ! Nr. des gewählten Menüeintrags LOCAL b$ ! Bildschirmspeichervariable DIM m$(11) ! Menüeintragsliste DIM k!(11) ! Dummyarray ' ............................................................................ SELECT w| ! Betrachte Nr. des gewählten Eintrags CASE 1 ! Eintrag Nr. 1: RESTORE stueckmenue ! Read-Zeiger setzen CASE 2 ! Eintrag Nr. 2: RESTORE hauptfile ! Read-Zeiger setzen CASE 3 ! Eintrag Nr. 3: RESTORE blockmenue ! Read-Zeiger setzen CASE 4 ! Eintrag Nr. 4: RESTORE parameter ! Read-Zeiger setzen CASE 5 ! Eintrag Nr. 5: RESTORE menue_exit ! Read-Zeiger setzen ENDSELECT ! Ende der Verzweigung ' ............................................................................ REPEAT ! Leseschleife INC i| ! Eintragszähler erhöhen READ m$(i|) ! Hauptmenüeintrag lesen UNTIL m$(i|)="##" ! Raus f nix eingelesen DEC i| ! Anzahl der Untermenüeinträge ' ............................................................................ IF w|=4 ! F Parameter-Rubrik gewählt IF g_midi! ! F Midi eingeschaltet LET m$(3)="Midi ausschalten" ! d ELSE ! F Midi ausgeschaltet LET m$(3)="Midi einschalten" ! d ENDIF ! d ENDIF ! d ' ............................................................................ SGET b$ ! Bildschirm retten @a_menue(-1,0,-1,0,0,-1,2+(w|-1)*11,1,1,i|,m|,q|,m$(),d!()) SPUT b$ ! Bildschirm wiederherstellen ' ............................................................................ IF m|=2 ! F Abbruch gewählt: GOTO raus_untermenue ! d ENDIF ! d @2_analyse(w|,q|) ! d raus_untermenue: ! d ERASE m$(),k!() ! Arrays löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_analyse(w|,q|) !_: ' ---------------------------------------------------------------------------- ' w| ! Nr des gewählten Eintrags im Hauptmenü ' q| ! Nr des gewählten Eintrags im Untermenü ' ............................................................................ IF w|=1 AND q|=1 ! d ' Stück auf Disk speichern @2_stueck_abspeichern ELSE IF w|=1 AND q|=2 ! d ' Stück von Disk laden @2_stueck_laden ELSE IF w|=1 AND q|=4 ! d ' Stück in Hauptfile speichern @1_abspeichern ELSE IF w|=1 AND q|=5 ! d ' Stück von Hauptfile laden @1_laden ELSE IF w|=1 AND q|=7 ! d ' bestimmte Stücke drucken @2_drucken_gewaehlte ELSE IF w|=1 AND q|=8 ! d ' bestimmte Stücke spielen @2_spielen_gewaehlte ELSE IF w|=2 AND q|=1 ! d ' Hauptfile neuanlegen @2_hauptfileneuanlegen ELSE IF w|=2 AND q|=2 ! d ' Hauptfile laden @2_hauptfile_laden ELSE IF w|=2 AND q|=3 ! d ' Hauptfile abspeichern @2_save_hauptfile ELSE IF w|=2 AND q|=5 ! d ' beliebiges File löschen @2_file_loeschen ELSE IF w|=2 AND q|=6 ! d ' File umbenennen @2_rename_file ELSE IF w|=2 AND q|=8 ! d ' Inhaltsverzeichnis drucken @2_inhverz_drucken ELSE IF w|=2 AND q|=9 ! d ' Alle Stücke drucken @2_drucken_ab_x_alle ELSE IF w|=2 AND q|=10 ! d ' Alle Stücke spielen @2_spielen_ab_x_alle ELSE IF w|=3 AND q|=1 ! d ' Anfang @1_blockmark(1) ELSE IF w|=3 AND q|=2 ! d ' Ende @1_blockmark(2) ELSE IF w|=3 AND q|=3 ! d ' Marken löschen @1_blockmark(3) ELSE IF w|=3 AND q|=5 ! d ' kopieren @1_block_kopieren ELSE IF w|=3 AND q|=6 ! d ' doppelt so schnell @3_bl_faehnchen(0) ELSE IF w|=3 AND q|=7 ! d ' halb so schnell @3_bl_faehnchen(-1) ELSE IF w|=3 AND q|=8 ! d ' transponieren @3_bl_transponieren ELSE IF w|=3 AND q|=10 ! d ' löschen @1_block_loeschen ELSE IF w|=4 AND q|=1 ! d ' Abspielgeschwindigkeit @1_abspielgeschw ELSE IF w|=4 AND q|=2 ! d ' Pause zw. den Stücken @1_stueckpause ELSE IF w|=4 AND q|=3 ! d ' Midi ein/aus @1_midi_ein_aus ELSE IF w|=5 AND q|=1 ! d ' Eingabe fortsetzen ELSE IF w|=5 AND q|=3 ! d @1_programmende(1) ELSE IF w|=5 AND q|=5 ! d @1_programmende(2) ENDIF ! d ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 2_stueck_abspeichern !_: ' ---------------------------------------------------------------------------- LOCAL ok! ! flag für Diskplatz~ LOCAL i| ! Notenzähler LOCAL j| ! Übergabezähler LOCAL a| ! Tonhöhe LOCAL b| ! Periodendauer LOCAL c| ! - 2 Oktaven? LOCAL e| ! + x Oktaven LOCAL tz| ! Taktnotenzähler ('Music-Writer':<=16 Noten/T.) LOCAL a$ ! Speicher für Übergabearrayeintrag, Kanal 1 LOCAL b$ ! Speicher für Übergabearrayeintrag, Kanal 2 LOCAL c$ ! Speicher für Übergabearrayeintrag, Kanal 3 LOCAL m$ ! Stückname LOCAL kl$ ! Klaviaturnegativ DIM t$(13) ! Notenbuchstabenarray DIM n$(g_os%) ! Übergabearray ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotogr. PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Gewählt: aktuelles Stück auf Disk speichern: alter Name: '"; PRINT g_fn$;"'" ! bisherigen Stücknamen angeben ' ............................................................................ @3_dfrei(802,ok!) ! sind noch 130404 Bytes auf Disk frei? IF NOT ok! ! F nicht: GOTO raus_stueck_abspeichern ! d ENDIF ! d ' ............................................................................ FILESELECT "A:\*.NTA",m$,m$ ! Fileselectbox ' ............................................................................ IF m$="" OR g_mn%=0 ! F Abbruch gewählt oder keine Note vorhanden GOTO raus_stueck_abspeichern ! d ELSE IF LEN(m$)>4 ! F Name mehr als 4 Buchstaben lang: LET g_fn$=LEFT$(m$,LEN(m$)-4) ! '.EXT' wegschneiden ENDIF ! d ' ............................................................................ RESTORE tonleiter ! Lesezeiger setzen FOR i|=1 TO 13 ! Alle Töne durch plus Pause READ t$(i|) ! Tonbuchstaben ('C'-'H','PP') einlesen NEXT i| ! nächster Ton LET g_n$(g_mn%+1)="Z101" ! Pause mit Taktstrich am Schluß FOR i|=1 TO g_mn%+1 ! Alle Noten des aktuellen Stücks durch LET a|=ASC(LEFT$(g_n$(i|),1))-64 ! Tonhöhe LET b|=VAL(MID$(g_n$(i|),2,1)) ! Periode, codiert wie in 'Notedita': ' ! 0=1/4,1=1/8,2=1/16,3=1/32,Noteditacodiert LET c|=VAL(MID$(g_n$(i|),3,1)) ! - 2 Oktaven? LET e|=0 ! erst mal Basisoktave (4) IF a|>12 AND a|<25 ! F obere Oktave LET e|=1 ! merken, daß obere Oktave LET a|=a|-12 ! zurechtstutzen für Tonbuchstabenarray ELSE IF a|=25 ! F höchstes C LET e|=2 ! Oktave merken LET a|=1 ! Tonbuchstabencode ELSE IF a|=26 ! F Pause LET a|=13 ! 13.Stelle als Buchstabe: t$(13)="PP" ENDIF ! d LET a$=a$+t$(a|) ! Tonbuchstaben in Übergabestring IF a|<>13 ! F keine Pause LET a$=a$+STR$(4-c|*2+e|) ! Oktavennummer (Tonumfang: C2-C6) ENDIF ! d LET a$=a$+STR$(5-b|) ! Periode, normcodiert: ' ! 5=1/4, 4=1/8, 3=1/16, 2=1/32, normcodiert LET b$=b$+"PP"+STR$(5-b|) ! Pausenstring für Kanal 2 LET c$=c$+"PP"+STR$(5-b|) ! Pausenstring für Kanal 3 INC tz| ! Taktzähler ('Music-Writer':<=16 Noten/Takt) +1 IF tz|>15 ! F 16. Note ohne Taktstrich: MID$(g_n$(i|+1),4,1)="1" ! Taktstrich bei nächster Note setzen ENDIF ! d IF VAL(RIGHT$(g_n$(i|+1),1)) ! nächste Note mit Taktstrich? LET n$(j|)=a$+"|" ! Übergabe für Kanal 1 INC j| ! Zähler für Übergabearray erhöhen LET n$(j|)=b$+"|" ! Übergabe für Kanal 2 INC j| ! Zähler für Übergabearray erhöhen LET n$(j|)=c$+"|" ! Übergabe für Kanal 3 INC j| ! Zähler für Übergabearray erhöhen CLR a$,b$,c$,tz| ! Speicher für Übergabearrayeinträge löschen ' ! und auch Taktnotenzähler löschen ENDIF ! d NEXT i| ! nächste Note ' ............................................................................ OPEN "O",#1,m$ ! File öffnen FOR i|=0 TO j| ! Alle normcodierten Zeilen durch PRINT #1,n$(i|) ! Zeile raus EXIT IF n$(i|)="" ! raus f Leerzeile NEXT i| ! Nächste Zeile CLOSE #1 ! File schließen ' ............................................................................ raus_stueck_abspeichern: ! d PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus ERASE n$() ! Übergabearray zerstören ERASE t$() ! Notenbuchstabenarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_stueck_laden !_: ' ---------------------------------------------------------------------------- LOCAL i| ! Notenpositionszähler LOCAL m% ! Anzahl der zu untersuchenden normcod.Textzln. LOCAL m$ ! Stückname LOCAL kl$ ! Klaviaturnegativ DIM n$(g_os%*3) ! Zwischenspeicherarray dimensionieren ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotogr. PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Gewählt: Einzelnes Stück von Disk laden: Aktuelles Stück geht verloren !!" ' ............................................................................ FILESELECT "A:\*.NTA",m$,m$ ! Fileselectbox ' ............................................................................ IF m$="" OR NOT EXIST(m$) ! F Abbruch gewählt: GOTO raus_stueck_laden ! d ELSE IF LEN(m$)>4 ! F Name mehr als 4 Buchstaben lang: LET g_fn$=LEFT$(m$,LEN(m$)-4) ! '.EXT' wegschneiden ENDIF ! d @a_undostueck ! Stück vorsichtshalber in Undoarray kopieren ' ............................................................................ OPEN "I",#1,m$ ! File öffnen LET i%=-1 ! bei Null starten WHILE NOT EOF(#1) ! F noch nicht End of file erreicht: INC i% ! Zeilenzähler für normcodierten Array erhöhen EXIT IF i%>g_os%*3 ! Raus f Dimensionierungsrahmen gesprengt würde LINE INPUT #1,n$(i%) ! Zeile einlesen ' RECALL #1,n$(),-1,dummy% ! Array in den Zwischenspeicherarray laden WEND ! ende CLOSE #1 ! File schließen LET i%=0 ! bei Null starten WHILE n$(i%)<>"" ! Schleife zum Auffinden des Arrayendes DELETE n$(i%+1) ! i|+1-ten Eintrag löschen (2.Stimme) DELETE n$(i%+1) ! i|+1-ten Eintrag löschen (3.Stimme) INC i% ! Positionszähler erhöhen WEND ! Ende erreicht LET m%=i%-1 ! Endtaktnummer errechnen ' ............................................................................ @3_rueckc(m%,n$()) ! Rückcodieren IF m%=-1 ! Katastrophe geschehen: GOTO raus_stueck_laden ! d ENDIF ! d ' ............................................................................ SPUT g_lb$ ! Bild von Infotext und Noten reinigen IF g_mn%>0 ! F überhaupt was da @2_stueck_ganz_zeigen ! Geladenes Stück auf Bildschirm IF g_mn%=g_os% ! F 200 Noten LET g_n%=g_mn% ! Cursor auf letze Note ELSE ! d LET g_n%=g_mn%+1 ! Notencursor auf Stückende: erst hier, ' ! da in 'geladenes_stueck' for-Schleife ENDIF ! d ELSE ! d LET g_n%=1 ! Endschreibmodus ENDIF ! d LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_stueck_laden: ! d PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus ERASE n$() ! Zwischenspeicherarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_rueckc(VAR m%,n$()) !_: ' ---------------------------------------------------------------------------- ' m% ! Anzahl der normcodierten Textzeilen, am Ende ' ! jedoch Abbruchflag ' n$(g_os%*3) ! Zwischenspeicherarray für normcodierten Text LOCAL a| ! Menüwahlvariable für Alertbox LOCAL i| ! Taktzähler für normcodierten Text LOCAL j| ! Zeichenzähler für normcodierte Textzeile LOCAL ml| ! Nummer der 1.Note im Takt merken LOCAL k| ! Notencode (1-13), 13=Pause, Rest Notenbuchst. LOCAL l| ! Notenzähler für 'Notedita'-cod. Notenarray LOCAL o| ! Oktavennummer LOCAL min_2_okt| ! Minuszweioktavenflag LOCAL obere_okt| ! untere Oktave (Flag) LOCAL p| ! Periodencode LOCAL a$ ! Notenbuchstabe oder Kreuz LOCAL b$ ! evtl. (falls a$="#") Notenbuchstabe LOCAL l$ ! einzulesender Notenbuchstabe LOCAL p$ ! Periodenzeichen LOCAL m$ ! Menütext ' ............................................................................ FOR i|=0 TO m% ! Alle Takte durch FOR j|=1 TO LEN(n$(i|))-1 ! Alle Zeichen im i|-ten Takt durch (bis auf ' ! Taktstrichzeichen am Ende IF j|=1 ! F noch am Taktanfang: LET ml|=l|+1 ! Nummer der 1.Note im Takt merken ENDIF ! d LET a$=MID$(n$(i|),j|,1) ! j|-tes Zeichen im i|-ten Takt festhalten INC j| ! Zeichenzähler erhöhen LET b$=MID$(n$(i|),j|,1) ! j|-tes Zeichen im i|-ten Takt festhalten IF a$="b" ! F unerlaubterweise 'b' statt '#': @4_btokreuz(a$,b$) ! aus 'b' '#' machen und b$ entsprechen ändern ENDIF ! RESTORE tonleiter ! Lesezeiger setzen CLR k| ! Notencodezähler null setzen REPEAT ! Leseschleife READ l$ ! Notenbuchstaben einlesen (evtl Kreuz davor) INC k| ! Notencode erhöhen IF k|>13 ! Falsches Zeichen LET m$="Codierfehler!|Falsches Zeichen|Taktnr:'"+STR$(i|)+"'" LET m$=m$+"/Abbruch" ! Menütext @a_alert(m$,a|) ! Alertbox ' PRINT g_n$(l|),l|,"Weiter? a$=";a$;" b$=";b$;" l$=";l$;" n$(";i|;")=";n$(i|) ! Martin Mittelmaier EXIT IF a| ! R f a| ENDIF ! d UNTIL l$=a$ OR l$=a$+b$ ! raus f Note gefunden EXIT IF a| ! R f a| IF l$=a$ ! f nicht beide Zeichen,sondern nur 1 verbraucht DEC j| ! Zeichenzähler erniedrigen ENDIF ! d IF (l$=a$ OR l$=a$+b$) AND (NOT l$="PP") ! f analysiertes Zeichen eine Note | Ufnaustr.3 1000 Berlin 21 INC j| ! Zeichenzähler erhöhen LET o|=VAL(MID$(n$(i|),j|,1)) ! j|-tes Zeichen im i|-ten Takt festh. SELECT o| ! Oktavennummer wird jetzt untersucht: CASE 2 ! F 2. Oktave LET min_2_okt|=1 ! Minuszweioktavenflag setzen LET obere_okt|=0 ! untere Oktave CASE 3 ! F 3. Oktave LET min_2_okt|=1 ! Minuszweioktavenflag setzen LET obere_okt|=1 ! Obere Oktave CASE 4 ! F 4. Oktave LET min_2_okt|=0 ! Minuszweioktavenflag löschen LET obere_okt|=0 ! untere Oktave CASE 5 ! F 5. Oktave LET min_2_okt|=0 ! Minuszweioktavenflag löschen LET obere_okt|=1 ! Obere Oktave CASE 6 ! F 6. Oktave, d.h. das höchste c LET min_2_okt|=0 ! Minuszweioktavenflag löschen LET obere_okt|=2 ! oberobere Oktave ENDSELECT ! d INC l| ! Notenzähler erhöhen LET g_n$(l|)=CHR$(64+k|+obere_okt|*12) ! Code überg. ELSE IF l$="PP" ! F Pause: INC l| ! Notenzähler erhöhen LET g_n$(l|)=CHR$(64+26)! Pausencode übergeben ELSE ! sonst: Unglück LET m$="Codierfehler!|Keine Note gefunden!|Taktnr:'"+STR$(i|)+"'" LET m$=m$+"/Abbruch!"! Menütext @a_alert(m$,a|) ! Alertbox EXIT IF a| ! R f a| ENDIF ! d EXIT IF a| ! R f a| INC j| ! Zeichenzähler erhöhen LET p$=MID$(n$(i|),j|,1) ! j|-tes Zeichen im i|-ten Takt festhalten ' ! 0=1/4,1=1/8,2=1/16,3=1/32,Noteditacodiert ' ! 5=1/4, 4=1/8, 3=1/16, 2=1/32, normcodiert LET p|=VAL(p$) ! Periodencodierung festhalten IF p|=5 OR p|=4 OR p|=3 OR p|=2 ! F 'Notedita'-mögliche Periodenwerte: LET p$=STR$(5-p|) ! Codieren wie in 'Notedita' ELSE ! kein 'Notedita'-möglicher Wert: LET m$="Codierfehler!|Periode falsch!|Taktnr:'"+STR$(i|)+"'" LET m$=m$+"/8-tel Note!"! Menütext @a_alert(m$,a|) ! Alertbox LET a|=0 ! Rausflag löschen, denn: LET p$="1" ! setze einfach 1/8-tel ENDIF ! d EXIT IF a| ! R f a| LET g_n$(l|)=g_n$(l|)+p$ ! Periodencode nach Notenstringarray übergeben LET g_n$(l|)=g_n$(l|)+STR$(min_2_okt|) ! Minuszweioktavenflag übergeben LET g_n$(l|)=g_n$(l|)+"0" ! Erst mal keinen Taktstrich übergeben ' PRINT g_n$(l|),l|,"Weiter? a$=";a$;" b$=";b$;" l$=";l$;" n$(";i|;")=";n$(i|) NEXT j| ! nächstes Zeichen im i|-ten Takt IF i|>0 ! F schön höher als erster Takt MID$(g_n$(ml|),4,1)="1" ! erste Note hat Taktstrich ENDIF ! d IF l|+1>g_os% ! f obere Schranke für Notenanz.überschr.w.würde LET m$="Codierfehler!|Zuviele Noten!|Taktnr:'"+STR$(i|)+"'" LET m$=m$+"/Abbruch" ! Menütext @a_alert(m$,a|) ! Alertbox LET a|=0 ! d LET i|=m% ! für Abbruch ohne Zerstörung sorgen ENDIF ! d EXIT IF a| ! R f a| NEXT i| ! nächster Takt; Maximum: m% IF a| ! F Rausflag gesetzt: LET m%=-1 ! Übergaberausflag setzen ENDIF ! d LET g_mn%=l| ! maximale Notennr übergeben ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 4_btokreuz(VAR y$,z$) !_: ' ---------------------------------------------------------------------------- ' y$ ! hier steht 'b' statt '#' ' z$ ! hier steht die zu erniedrigende Note ('C'-'H') LET y$="#" ! d IF z$="C" ! d LET z$="H" ! d ELSE IF z$="D" ! d LET z$="C" ! d ELSE IF z$="E" ! d LET z$="D" ! d ELSE IF z$="F" ! d LET z$="E" ! d ELSE IF z$="G" ! d LET z$="F" ! d ELSE IF z$="A" ! d LET z$="G" ! d ELSE IF z$="H" ! d LET z$="A" ! d ENDIF ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_abspeichern !_: ' ---------------------------------------------------------------------------- ' Ein Notentext wird gespeichert. ' ---------------------------------------------------------------------------- LOCAL z! ! Flag für Halbtoncheck LOCAL stuecknr| ! d LOCAL a| ! Wahlknopf für Alertbox LOCAL m| ! Maustastenvar. für Menü LOCAL s% ! Zähler für schwarze Tasten LOCAL w% ! Zähler für weiße Tasten LOCAL n% ! zähler für Notenposition LOCAL a$ ! Zwischenspeicher für Notencode LOCAL s$ ! Abkürzungsvariable LOCAL kl$ ! Klaviaturnegativ ' ............................................................................ ' 0.) H a l b t o n c h e c k : ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotogr. PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);" Gewählt: Abspeichern " ! Infotext/'Löschen'löschen ' ............................................................................ @2_shwtch(s%,w%,z!) ! Mehr schwarze als weiße Tasten ? IF z! ! f mehr schwarze als weiße Tasten: @a_alert("Mehr schwarze '"+STR$(s%)+"'|als weiße Tasten! '"+STR$(w%)+"'/Ok!|Abbruch!",a|) IF a|=2 ! f Abbruch gewählt GOTO raus_abspeichern ! uverrichteter Dinge raus ENDIF ! d ENDIF ! d ' ............................................................................ @2_speichermenu(stuecknr|) ! großes Menü ausfahren: StÜcknr wählen IF stuecknr|=0 ! F Abbruch gewählt GOTO raus_abspeichern ! uverrichteter Dinge raus ENDIF ! d ' ............................................................................ WHILE NOT EXIST(g_hf$) ! Solange Notenhauptdatei nicht auf Disk @a_alert("Diskette mit| Hauptfile|einlegen!/Ok!|Abbruch!",a|) IF a|=2 ! f Abbruch gewählt GOTO raus_abspeichern ! uverrichteter Dinge raus ENDIF ! d WEND ! d6 ' ............................................................................ LET g_fn$=MID$(g_stueck$(0),(stuecknr|-1)*8+1,8) ! Stückname ermitteln PRINT AT(50,1);"Stückname:'";g_fn$;"'"! Infotext IF g_fn$="________" ! Code für Löschen @2_stueck_loeschen(stuecknr|) ! d GOTO raus_abspeichern ! raus ENDIF ! d ' ............................................................................ g_stueck$(stuecknr|+1)=STRING$(800,"@") ! Speicherstring auffüllen +1, weil in ' ! g_stueck$(1) die Datumsliste drin ist. FOR n%=1 TO g_mn% ! Alle Notenpositionen durch MID$(g_stueck$(stuecknr|+1),(n%-1)*4+1,4)=g_n$(n%) ! Notencode übergeben NEXT n% ! nächste Notenposition ' ............................................................................ OPEN "U",#1,g_hf$ ! Datei öffnen 'U'=Update, ja nich 'O'!! PRINT #1,g_stueck$(0) ! Namenliste abspeichern PRINT #1,g_stueck$(1) ! Datumliste abspeichern SEEK #1,1281+1282+(stuecknr|-1)*802+1 ! Datenzeiger positionieren: ' ! Für 'SEEK' gilt: 0.Position bis ' ! 160*8-1=1279.Pos. sind Namen, dann ' ! 1280: LF, und 1281: CR, dann: ' ! 1282 bis 1281+160*8=2561 sind Datum, ' ! 2562: LF, und 2563(=1281+1282): CR, ' ! Wegen LF+CR am Ende jedes Strings im ' ! Folgenden 802 statt 200*4=800 ! PRINT #1,g_stueck$(stuecknr|+1) ! Akt. Notenstück abspeichern,+1, da in ' ! g_stueck$(1) die Datumsliste drin ist. CLOSE #1 ! Datei schließen ' ............................................................................ @1_fileselectboxfoto ! Fileselectbox fotografieren ' ............................................................................ raus_abspeichern: ! Rauslabel PUT 0,0,g_kl$ ! Klaviatur von Infotext reinigen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_shwtch(VAR s%,w%,z!)!_: ' ---------------------------------------------------------------------------- ' Hier wird gecheckt, wieviele der Noten im aktuellen Stück schwarzen und ' wieviele weißen entsprechen. ' ---------------------------------------------------------------------------- ' z! ! Flag: mehr schwarze als weiße Tasten ? (ja=-1) ' s% ! Zähler für schwarze Tasten ' w% ! Zähler für weiße Tasten LOCAL a| ! Tonhöhe LOCAL i% ! Zähler für Noten im aktuellen Stück ' ............................................................................ FOR i%=1 TO g_mn% ! Alle Noten durch LET a|=ASC(LEFT$(g_n$(i%),1))-64 ! Tonhöhe (1-25) SELECT a| ! Betrachte die Tonhöhe CASE 2,4,7,9,11,14,16,19,21,23 ! f schwarze Taste: INC s% ! Zähler für schwarze Taste erhöhen DEFAULT ! Ansonsten ist's ja 'ne weiße Taste: INC w% ! Zähler für weiße Taste erhöhen ENDSELECT ! Ende NEXT i% ! nächste Note IF s%>w% ! F mehr schwarze als weiße Tasten: LET z!=TRUE ! d ENDIF ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_speichermenu(VAR w|)!_: ' ---------------------------------------------------------------------------- ' w| ! Wahlvariable LOCAL mw| ! Wahlvariablenmerker LOCAL m| ! Maustastenvar. für Menü LOCAL i| ! Zähler LOCAL b$ ! Zwischenspeicherstring LOCAL d$ ! Datum LOCAL i$ ! Infotext LOCAL c$ ! Bildschirmspeichervariable ' ............................................................................ DIM a$(g_stka|) ! Menüeintragsfelderarray dim. DIM b$(g_stka|) ! Menüeintragsfelderarray dim. DIM a%(g_stka|) ! Nummerierungsarray dim. ' ............................................................................ SGET c$ ! Bildschirm retten ' ............................................................................ SPUT g_fsb$ ! Fileselectbox raus PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext LET i$=" Gewählt: Abspeichern / Löschen " ! Infotext LET i$=i$+" B i s h e r i g e r Name:'" ! Infotext LET i$=i$+g_fn$ ! Infotext FOR i|=1 TO g_stka| ! Alle Menüeinträge durch IF g_fn$=MID$(g_stueck$(0),(i|-1)*8+1,8) AND g_fn$<>"________" ! FNamen gef. LET i$=i$+"' Nr.:'"+STR$(i|)+"'" ! physikalische Nummer merken ENDIF ! d NEXT i| ! nächster Menüeintrag PRINT AT(1,1);i$; ! Infotext anzeigen ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Menüeinträge durch LET a$(i|)=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Ins Menüeintragsfeld kopieren LET b$(i|)=a$(i|) ! physik. Array in b$() retten LET a%(i|)=i| ! Nummerierungsarrayeintrag NEXT i| ! nächster Menüeintrag ' ............................................................................ QSORT a$(),g_stka|+1,a%() ! Sortieren, a$() jetzt logisch ' ............................................................................ ' ! 1.) Erst mal den Stücknamen: ' ............................................................................ @a_menue(0,0,-1,0,-1,-1,4,4,8,20,m|,mw|,a$(),d!()) ! Menüprozedur aufrufen IF mw|=0 OR LEFT$(a$(mw|),2)="-1" ! F nichts gewählt oder Abbruch: LET mw|=0 ! f Abbruch (b$(w|)="-1"):mw|=0 GOTO raus_speichermenue ! raus ENDIF ! d LET w|=a%(mw|) ! wirkliche,phys.Wahlnrermitteln LET b$(w|)=a$(mw|) ! Neuen Stücknamen an physik. ' ! Stringarray übergeben ' ............................................................................ g_stueck$(0)="" ! Stücknamenteil leer machen FOR i|=1 TO g_stka| ! Alle Stücknamen durch LET g_stueck$(0)=g_stueck$(0)+b$(i|) ! neuerEintrag inStücknamenliste NEXT i| ! nächster Stückname ' ............................................................................ ' ! 2.) Datum: ' ............................................................................ ' PRINT AT(1,1);"'";MID$(g_stueck$(1),(w|-1)*8+1,8);"' " IF MID$(g_stueck$(1),(w|-1)*8+1,8)="________" ! F bisher kein Datum: LET d$=LEFT$(DATE$,6)+RIGHT$(DATE$,2) ! '19' von date$ rausschneiden MID$(g_stueck$(1),(w|-1)*8+1)=d$ ! Datum übergeben ENDIF ! d ' ............................................................................ ' ! Restarbeit: ' ............................................................................ raus_speichermenue: ! Rauslabel SPUT c$ ! Bildschirm wieder herstellen ' ............................................................................ ERASE a$() ! Menüeintragsarray löschen ERASE b$() ! Menüeintragsarray löschen ERASE a%() ! Nummerierungsarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_stueck_loeschen(s|) !_: ' ---------------------------------------------------------------------------- ' s| ! Stücknummer ' ............................................................................ PRINT AT(1,1);" Gewählt: Löschen " ! Infotext LET g_stueck$(s|)=STRING$(800,"@") ! Stück mit Leerzeichen füllen ' ............................................................................ OPEN "U",#1,g_hf$ ! Datei öffnen 'U'=Update, ja nich 'O'!! PRINT #1,g_stueck$(0) ! Namenliste abspeichern ' ! Datenzeiger positionieren: SEEK #1,1281+(s|-1)*802+1 ! positionieren (Erkl. siehe 'laden') PRINT #1,g_stueck$(s|) ! Aktuelles Notenstück abspeichern CLOSE #1 ! Datei schließen ' ............................................................................ @1_fileselectboxfoto ! Fileselectbox fotografieren ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_laden !_: ' ---------------------------------------------------------------------------- ' Ein Notentext wird geladen. Danach wird das Notenstück auf den Monitor ge- ' bracht. ' ---------------------------------------------------------------------------- LOCAL stuecknr| ! d LOCAL dummy| ! Dummy für Alertbox LOCAL n% ! zähler für Notenposition LOCAL a$ ! Zwischenspeicher für Notencode LOCAL s$ ! Abkürzungsvariable ' ............................................................................ @2_lademenue("Laden",stuecknr|) ! großes Menü ausfahren: StÜcknr wählen IF stuecknr|=0 ! F Abbruch gewählt GOTO raus_laden ! uverrichteter Dinge raus ENDIF ! d @a_undostueck ! Stück vorsichtshalber in Undoarray ' ............................................................................ LET g_fn$=MID$(g_stueck$(0),(stuecknr|-1)*8+1,8) ! Stückname ermitteln PRINT AT(50,1);"Neuer Stückname:'";g_fn$;"'"! Infotext ' ............................................................................ LET s$=g_stueck$(stuecknr|+1) ! Abkürzungsvariable füllen +1,weil in ' ! g_stueck$(1) die Datumsliste drin ist. FOR n%=1 TO g_os% ! Alle Notenpositionen durch LET a$=MID$(s$,(n%-1)*4+1,4) ! Notencode (= 4 Zeichen) ermitteln EXIT IF a$="@@@@" ! Raus f Leernote LET g_n$(n%)=a$ ! Notencode übergeben NEXT n% ! nächste Notenposition LET g_mn%=n%-1 ! Endnotennr festlegen ' ............................................................................ SPUT g_lb$ ! Bild von Infotext und Noten reinigen IF g_mn%>0 ! F überhaupt was da @2_stueck_ganz_zeigen ! Geladenes Stück auf Bildschirm IF g_mn%=g_os% ! F 200 Noten LET g_n%=g_mn% ! Notencursor auf letzten Note ELSE ! d LET g_n%=g_mn%+1 ! Notencursor auf Stückende: erst hier, ' ! da in 'geladenes_stueck' for-Schleife ENDIF ! d ELSE ! d LET g_n%=1 ! Endschreibmodus ENDIF ! d LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ' ............................................................................ raus_laden: ! Rauslabel PUT 0,0,g_kl$ ! Klaviatur von Infotext reinigen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_lademenue(i$,VAR w|)!_: ' ---------------------------------------------------------------------------- ' i$ ! Name der aufrufenden Prozedur ' w| ! Wahlvariable LOCAL i| ! Zählvariable LOCAL m| ! Maustastenvar. für Menü LOCAL mw| ! Merker für Wahlvariable LOCAL m$ ! Merker für Eintragsnamen LOCAL c$ ! Bildschirmspeichervariable DIM a$(g_stka|) ! Menüeintragsfelderarray dim. DIM a%(g_stka|) ! Nummerierungsarray dim. ' ............................................................................ SGET c$ ! Bildschirm retten ' ............................................................................ SPUT g_fsb$ ! Fileselectbox raus LET i$=" Gewählt: "+i$+" " ! Infotext LET i$=i$+" B i s h e r i g e r Name:'" ! Infotext LET i$=i$+g_fn$+"' " ! Infotext PRINT AT(1,1);i$; ! Infotext anzeigen ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Menüeinträge durch LET a$(i|)=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Ins Menüeintragsfeld kopieren LET a%(i|)=i| ! Nummerierungsarrayeintrag NEXT i| ! nächster Menüeintrag ' ............................................................................ QSORT a$(),g_stka|+1,a%() ! Sortieren ' ............................................................................ @a_menue(0,0,-1,0,0,-1,4,4,8,20,m|,w|,a$(),d!())! Menü aufrufen ohne Darstellung IF w|=0 OR a$(w|)="-" ! F nichts gewählt oder Abbruch: LET w|=0 ! f Abbruch (b$(w|)="-1"):mw|=0 GOTO raus_lademenue ! raus ENDIF ! d ' ............................................................................ DO ! Schleife für Datumsdarstellung ' .......................................................................... EXIT IF m|=1 OR w|=0 ! Raus f linke Maustaste ' .......................................................................... IF mw|<>0 ! F schonmal Datum angeguckt: LET a$(mw|)=m$ ! Letzten Namen wiederherstellen ENDIF ! d ' .......................................................................... LET m$=a$(w|) ! Namen retten LET mw|=w| ! Wahlnummer retten ' .......................................................................... LET a$(w|)=MID$(g_stueck$(1),(a%(w|)-1)*8+1,8)! Datum übergeben ' .......................................................................... @a_menue(-1,0,-1,0,0,-1,4,4,8,20,m|,w|,a$(),d!())! Menü mit Darstellung ' .......................................................................... LOOP ! Schleifenende ' ............................................................................ LET w|=a%(w|) ! wirkliche Wahlnummer ermitteln ' ............................................................................ raus_lademenue: ! Rauslabel SPUT c$ ! Bildschirm wieder herstellen ' ............................................................................ ERASE a$() ! Menüeintragsarray löschen ERASE a%() ! Nummerierungsarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_stueck_ganz_zeigen !_: ' ---------------------------------------------------------------------------- ' Das Notenstück im Speicherstring wird auf dem Monitor dargestellt. ' ---------------------------------------------------------------------------- LOCAL b| ! Periodendauer LOCAL c| ! - 2 Oktaven? LOCAL d| ! Taktstrich? LOCAL m| ! Menüvar. LOCAL a% ! Tonhöhe LOCAL m$ ! Menütextvar. ' ............................................................................ FOR g_n%=1 TO g_mn% ! Alle Noten durch LET a%=ASC(LEFT$(g_n$(g_n%),1))-64 ! Tonhöhe IF a%<0 ! F kaputte Tonhöhe LET m$="Achtung! Fehler|in '2_stueck_ganz_zeigen'|bei Notennr:'" LET m$=m$+STR$(g_n%)+"'|Stück '"+g_fn$+"' ist futsch! /raus!" @a_alert(m$,m|) ! d EXIT IF TRUE ! unverrichteter Dinge raus ENDIF ! d LET b|=VAL(MID$(g_n$(g_n%),2,1)) ! Periode LET c|=VAL(MID$(g_n$(g_n%),3,1)) ! - 2 Oktaven? LET d|=VAL(RIGHT$(g_n$(g_n%),1)) ! Taktstrich? PUT g_x%(g_n%),g_y%(g_n%),g_nb$(a%,b|,c|,d|),7 ! Note auf Bildschirm ' ! Schneller als die letzten 5 Zln wäre: ' PUT g_x%(g_n%),g_y%(g_n%),g_nb$(ASC(LEFT$(g_n$(g_n%),1))-64,VAL(MID$(g_n$(g_n%),2,1)),VAL(MID$(g_n$(g_n%),3,1)),VAL(RIGHT$(g_n$(g_n%),1))),7 NEXT g_n% ! Nächste Note ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_drucken_gewaehlte !_: ' ---------------------------------------------------------------------------- ' Notentexte werden gedruckt; ausgewählte Stücke ' ---------------------------------------------------------------------------- LOCAL r! ! Rausvariable 1 LOCAL r| ! Rausvariable 2 LOCAL i| ! Stückzähler LOCAL w| ! Wahlvariable fürs Menü LOCAL m_mn% ! Merker für letzte Note LOCAL m_n% ! Merker für Cursorposition LOCAL a$ ! Zwischenspeicher für Notencode LOCAL s$ ! Abkürzungsvariable LOCAL bld$ ! Bildschirmrettungsnegativ LOCAL name$ ! Stückname DIM w!(g_stka|) ! Auswahlarray, Eintrag=-1,f entspr. ' ! Stück ausgewählt worden ist. DIM w|(g_stka|) ! Alphabetnummerarray löschen DIM m_n$(g_os%) ! Zwischenspeicher für akt. Stück ' ............................................................................ ' 1.) l e t z t e s S t ü c k r e t t e n : ' ............................................................................ SGET bld$ ! Bildschirm retten LET name$=g_fn$ ! Namen retten LET m_mn%=g_mn% ! letzte Note des akt. Stücks merken LET m_n%=g_n% ! Cursorposition des akt. Stücks merken IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO g_mn% ! Alle Noten des akt. Stücks durch LET m_n$(n%)=g_n$(n%) ! Stück in Speicherstring NEXT n% ! nächste Note des akt. Stücks ENDIF ! d ' ............................................................................ ' 2.) V o r b e r e i t u n g e n : ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus @3_dm("drucken",w|,w!(),w|()) ! großes Menü ausfahren: StÜcke wählen IF w|=0 ! F Abbruch gewählt GOTO raus_drucken_gewaehlte ! uverrichteter Dinge raus ENDIF ! d FOR i|=1 TO g_stka| ! Alle Stücke durch (physikalisch) EXIT IF LEFT$(g_stueck$(i|+1),4)="@@@@" ! raus f leeres Stück IF w!(i|)=TRUE ! F Stück gedruckt werden soll: @3_dr_st(i|,w|(i|),r!) ! Eine Ebene weiter runter zum Drucken ENDIF ! d IF r!=TRUE ! F abgebrochen: LET r!=FALSE ! d @a_alert("Ganz abbrechen?/Ja|Nein",r|) ! d EXIT IF r|=1 ! Raus f ja gewählt: ENDIF ! d EXIT IF r|=1 ! Raus f ja gewählt: NEXT i| ! nächstes Stück ' ............................................................................ ' 4.) S t ü c k w i e d e r h e r s t e l l e n : ' ............................................................................ raus_drucken_gewaehlte: ! Rauslabel IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO m_mn% ! Alle Noten des akt. Stücks durch LET g_n$(n%)=m_n$(n%) ! Stück von Speicherstring in Arbeitsstr NEXT n% ! nächste Note des akt. Stücks ENDIF ! d LET g_fn$=name$ ! Stückname wiederherstellen LET g_n%=m_n% ! Cursor wo er früher war LET g_mn%=m_mn% ! vorher akt. Stück SPUT bld$ ! Bildschirm wiederherstellen ERASE w!() ! Wahlarray löschen ERASE w|() ! Alphabetnummerarray löschen ERASE m_n$() ! Speicherarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_dm(z$,VAR w|,w!(),w|())!_: ' ---------------------------------------------------------------------------- ' z$ ! Name von aufrufender Prozedur ' w| ! Wahlvar.=-1:was gewählt,0:nix ' w!() ! Wahlarray ' w|() ! Array für alphab. Stücknr. LOCAL i| ! Zählvariable LOCAL m| ! Maustastenvar. für Menü LOCAL c$ ! Bildschirmnegativ LOCAL i$ ! Infotext DIM a!(g_stka|) ! Eintragswahlfelderarray dim. DIM a$(g_stka|) ! Menüeintragsfelderarray dim. DIM a%(g_stka|) ! Nummerierungsarray dim. ' ............................................................................ SGET c$ ! Bildschirm retten ' ............................................................................ SPUT g_fsb$ ! Fileselectbox raus LET i$=" Gewählt: "+z$+" " ! Infotext PRINT AT(1,1);i$; ! Infotext anzeigen ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Menüeinträge durch LET a$(i|)=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Ins Menüeintragsfeld kopieren LET a%(i|)=i| ! Nummerierungsarrayeintrag NEXT i| ! nächster Menüeintrag ' ............................................................................ QSORT a$(),g_stka|+1,a%() ! Sortieren, alphabetisch, in ' ! a%() wird die physikalische ' ! Nr. mitsortiert. ' ............................................................................ @a_menue(0,0,-1,-1,0,-1,4,4,8,20,m|,w|,a$(),a!())! Menü aufrufen ohne Darstellung IF w|=0 ! f nichts gewählt: GOTO raus_druck_menue ! d ENDIF ! d ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Stücke durch, und zwar in ' ! alphabetischer Reihenfolge IF a!(i|)=TRUE ! F Stück gewählt: LET w!(a%(i|))=TRUE ! Wahlarray kennzeichnen und ' ! zwar an der physikalische Nr. LET w|(a%(i|))=i| ! Alphabetnr. merken ELSE ! F Stück nicht gewählt: LET w!(a%(i|))=FALSE ! In Wahlarray übergeben ENDIF ! d NEXT i| ! nächstes Stück ' ............................................................................ SPUT c$ ! Bildschirm wieder herstellen ' ............................................................................ raus_druck_menue: ! d ERASE a!() ! Menüwahlarray löschen ERASE a$() ! Menüeintragsarray löschen ERASE a%() ! Nummerierungsarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_dr_st(i|,a|,VAR z!) !_: ' ---------------------------------------------------------------------------- ' Hier wird ein einzelnes Stück angezeigt und evtl. gedruckt. ' ............................................................................ ' i| ! physikalische Stücknummer ' a| ! alphabetische Stücknummer ' z! ! Rausflag ' ............................................................................ LOCAL lz| ! Nummer der letzten Zeile LOCAL m| ! Menüvariable LOCAL j| ! Ziffernzähler für Stücknummer LOCAL n% ! zähler für Notenposition LOCAL y% ! y-Startwert für Zeilenradiergummibox LOCAL a$ ! alphab. Stücknr-/Notencodespeicher LOCAL p$ ! phys. Stücknrspeicher LOCAL name$ ! d LOCAL datu$ ! Datum LOCAL stuecknummer$ ! physikalische Stücknummer LOCAL menue$ ! Alertboxtext ' ............................................................................ ' 1.) B i l d - V o r b e r e i t u n g e n : ' ............................................................................ SPUT g_lb$ ! Löschbild DEFFILL 0 ! Füllmuster weiß PBOX 0,0,g_bb%-1,g_mh|-2 ! Klaviatur wegradieren DEFFILL 1,2,8 ! Füllmuster schwarz ' ............................................................................ ' 2.) T i t e l z e i l e f ü r d a s S t ü c k : ' ............................................................................ CLS ! Bildschirm ganz leer LET a$=STR$(i|) ! Stücknummer DEFTEXT 1,0,0,4 ! kleine Schrift FOR j|=1 TO LEN(a$) ! alle Ziffern von i| durch TEXT 10,10+j|*6,MID$(a$,j|,1) ! Ziffern untereinander schreiben NEXT j| ! nächste Ziffer GET 10,10,30,50,p$ ! Nummer fotografieren LET a$=STR$(a|) ! alphabetische Stücknummer DEFTEXT 1,0,0,4 ! kleine Schrift FOR j|=1 TO LEN(a$) ! alle Ziffern von a| durch TEXT 10,100+j|*6,MID$(a$,j|,1) ! Ziffern untereinander schreiben NEXT j| ! nächste Ziffer GET 10,100,30,140,a$ ! Nummer fotografieren CLS ! Bildschirm ganz leer PUT g_x%(6)+10,g_y%(6)+28,p$ ! physikalische Stücknummer ausgeben PUT g_x%(86)+10,g_y%(86)+28,a$ ! alphabetische Stücknummer ausgeben ' ............................................................................ ' 3.) g e w ä h l t e s S t ü c k r a u s f i l t e r n : ' ............................................................................ LET s$=g_stueck$(i|+1) ! Abkürzungsvariable füllen +1,weil in ' ! g_stueck$(1) die Datumsliste drin ist. FOR n%=1 TO g_os% ! Alle Notenpositionen durch LET a$=MID$(s$,(n%-1)*4+1,4) ! Notencode (= 4 Zeichen) ermitteln EXIT IF a$="@@@@" ! Raus f Leernote LET g_n$(n%)=a$ ! Notencode übergeben NEXT n% ! nächste Notenposition LET g_mn%=n%-1 ! Endnotennr festlegen IF g_mn%=0 ! F überhaupt nix da GOTO raus_drucke_st ! Rauslabel ENDIF ! d ' ............................................................................ ' 4.) E n d l i c h D r u c k b i l d : ' ............................................................................ LET g_fn$=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Stückname ermitteln @4_druckbildhaelfte(1) ! 1. Hälfte des Stücks auf Bildschirm LET menue$="'"+g_fn$+"' Wirklich drucken?/Ja|Nein" ! d @a_alert(menue$,m|) ! d IF m|=2 ! Nein gewählt: LET z!=TRUE ! Rausvariable setzen GOTO raus_drucke_st ! raus ENDIF ! d HIDEM ! Mauspfeil weg ' ! Folgende Zeile bei PD-Version raus: LPRINT CHR$(27);CHR$(106);CHR$(100); ! r e v e r s e s the paper,page 140 IF NOT GEMDOS(17) ! F Drucker nicht bereit: @a_alert("Drucker nicht bereit!/Aber jetzt!|raus!",m|) ! d ENDIF ! d IF m|=2 ! Nein gewählt: LET z!=TRUE ! Rausvariable setzen GOTO raus_drucke_st ! raus ENDIF ! d HARDCOPY ! d CLS ! Bildschirm löschen @4_druckbildhaelfte(2) ! 2. Hälfte des Stücks auf Bildschirm HARDCOPY ! d CLS ! Bildschirm löschen FOR i|=1 TO 8 ! Vorschubschleife (*) LPRINT ! Zeilenvorschub NEXT i| ! nächster Zeilenvorschub ' LPRINT CHR$(27);CHR$(74);CHR$(5); ! Korrekturvorschub n/216 inch ' ............................................................................ raus_drucke_st: ! Rauslabel ' ---------------------------------------------------------------------------- ' (*) Zwischen den beiden Stückhälften sind noch ein paar Zeilenvorschübe ' beim Drucken nötig, da zwischen den Notenzeilen sonst ja immer eine ' ganze Leerzeile ist, hier aber nur die obere Menüzeile, die etwas ' weniger hoch als eine Notenzeile ist. ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 4_druckbildhaelfte(h|)!_: ' ---------------------------------------------------------------------------- LOCAL m| ! Menüvar. LOCAL a| ! Tonhöhe LOCAL b| ! Periodendauer LOCAL c| ! - 2 Oktaven? LOCAL d| ! Taktstrich? LOCAL rest| ! Notenzeilenhöhe - Menühühe LOCAL c% ! Cursorposition LOCAL s% ! Startnotennummer LOCAL e% ! Endnotennummer LOCAL n% ! Notennummer im zu druckenden Stückteil LOCAL b$ ! Bildschirmspeicherstring LOCAL m$ ! Menütextvar. ' ............................................................................ LET c%=7 ! Cursorposition am Anfang LET s%=1+(h|-1)*(3*34) ! Startnotennummer festlegen IF g_mn%<s% ! Endnote des Stücks < Startnummer: GOTO raus_druckbildhaelfte ! raus ENDIF ! d IF h|=2 ! f 2.Stückhälfte angezeigt werden soll: LET e%=g_mn% ! Endnotennummer festlegen ELSE ! f 1.Stückhälfte angezeigt werden soll: IF g_mn%<3*34 ! f Endnote d.Stücks < 3 Zln voll Noten: LET e%=g_mn% ! Endnotennummer festlegen ELSE ! f Endnote d.Stücks = 3 Zln voll Noten: LET e%=3*34 ! Endnotennummer festlegen ENDIF ! d ENDIF ! d ' ............................................................................ LET b|=VAL(MID$(g_n$(g_mn%),2,1)) ! Periode der letzten Note IF b|=3 AND g_mn%>3 AND g_mn%-e%<3 ! F letzte Note 1/32 und > 3 Noten da: LET e%=e%-2 ! Soundmarkierungen beim Absp. weglassen ENDIF ! d FOR n%=s% TO e% ! Alle Noten des Stückteils durch ' .......................................................................... IF c%=7 OR c%=87 OR c%=167 ! f Cursor am Zeilenanfang: PUT g_x%(c%-1),g_y%(c%-1),g_ln$,7 ! Notenlinien für Notenschlüssel PUT g_x%(c%-2),g_y%(c%-2),g_ln$,7 ! Notenlinien für Notenschlüssel PUT g_x%(c%-2),g_y%(c%-2),g_ns$,7 ! Notenschlüssel projezieren PUT g_x%(c%-2)+3,g_y%(c%-2)+3,g_ns$,7 ! Schatten Notenschlüssel ENDIF ! d ' .......................................................................... PUT g_x%(c%),g_y%(c%),g_ln$ ! Notenlinien für abzubildende Note IF ASC(LEFT$(g_n$(n%),1))-64<0 ! F kaputte Tonhöhe LET m$="Achtung! Fehler|in '4_druckbildhaelfte'|bei Notennr:'" LET m$=m$+STR$(g_n%)+"'|Stück:'"+g_fn$+"'ist futsch! /raus!" @a_alert(m$,m|) ! d EXIT IF TRUE ! unverrichteter Dinge raus ENDIF ! d LET a|=ASC(LEFT$(g_n$(n%),1))-64 ! Tonhöhe LET b|=VAL(MID$(g_n$(n%),2,1)) ! Periode LET c|=VAL(MID$(g_n$(n%),3,1)) ! - 2 Oktaven? LET d|=VAL(RIGHT$(g_n$(n%),1)) ! Taktstrich ? PUT g_x%(c%),g_y%(c%),g_nb$(a|,b|,c|,d|),7 ! Note auf Bildschirm ' .......................................................................... INC c% ! Cursorposition erhöhen IF c%=41 OR c%=121 ! f Cursor an Position 41 oder 121 ADD c%,46 ! eine Notenzeile überspringen ENDIF ! d ' .......................................................................... NEXT n% ! nächste Note des Stückteils ' ............................................................................ GET 0,g_y%(1),g_bb%-1,g_bh%-1,b$ ! Bild fotografieren CLS ! Bildschirm löschen IF h|=1 ! f 1.Stückhälfte angezeigt werden soll: PUT 0,0,b$ ! Bild wieder projezieren, aber jetzt ' ! ganz oben anfangen, um nix an Papier ' ! zu verschenken ELSE ! f 2.Stückhälfte angezeigt werden soll: LET rest|=g_nzlh|-g_mh| ! Notenzeilenhöhe - Menühühe,Erklärung: PUT 0,rest|,b$ ! Bild wieder projezieren, aber jetzt ' ! etwas weiter unten, weil ja immer ' ! zwischen zwei gefüllten Notenzeilen ' ! genau eine Leerzeile der Höhe ' ! g_nzlh| sein soll. ENDIF ! d ' ............................................................................ raus_druckbildhaelfte: ! Rauslabel ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_spielen_gewaehlte !_: ' ---------------------------------------------------------------------------- ' Notentexte werden gespielt; ausgewählte Stücke. Prozedurbau sehr ähnlich dem ' bei '2_drucken_gewaehlte'. ' ---------------------------------------------------------------------------- LOCAL r! ! Rausvariable 1 LOCAL r| ! Rausvariable 2 LOCAL i| ! Stückzähler LOCAL w| ! Wahlvariable fürs Menü LOCAL m_mn% ! Merker für letzte Note LOCAL m_n% ! Merker für Cursorposition LOCAL a$ ! Zwischenspeicher für Notencode LOCAL s$ ! Abkürzungsvariable LOCAL bld$ ! Bildschirmrettungsnegativ LOCAL name$ ! Name des gespielten Stücks DIM w!(g_stka|) ! Auswahlarray, Eintrag=-1,f entspr. ' ! Stück ausgewählt worden ist. DIM w|(g_stka|) ! Alphabetnummerarray löschen DIM m_n$(g_os%) ! Zwischenspeicher für akt. Stück ' ............................................................................ ' 1.) l e t z t e s S t ü c k r e t t e n : ' ............................................................................ SGET bld$ ! Bildschirm retten LET m_mn%=g_mn% ! letzte Note des akt. Stücks merken LET m_n%=g_n% ! Cursorposition des akt. Stücks merken LET name$=g_fn$ ! Namen retten IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO g_mn% ! Alle Noten des akt. Stücks durch LET m_n$(n%)=g_n$(n%) ! Stück in Speicherstring NEXT n% ! nächste Note des akt. Stücks ENDIF ! d ' ............................................................................ ' 2.) V o r b e r e i t u n g e n : ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus @3_dm("abspielen",w|,w!(),w|()) ! großes Menü ausfahren: StÜcke wählen IF w|=0 ! F Abbruch gewählt GOTO raus_spielen_gewaehlte ! uverrichteter Dinge raus ENDIF ! d FOR i|=1 TO g_stka| ! Alle Stücke durch (physikalisch) EXIT IF LEFT$(g_stueck$(i|+1),4)="@@@@" ! raus f leeres Stück IF w!(i|)=TRUE ! F Stück gespielt werden soll LET s$=g_stueck$(i|+1) ! Stück kopieren FOR j|=1 TO g_os% ! Alle Noten d.i|-ten St.durch LET g_n$(j|)=MID$(s$,(j|-1)*4+1,4) ! ins aktuelle Stück kopieren EXIT IF g_n$(j|)="@@@@" ! F leere Note NEXT j| ! nächste Note LET g_mn%=j|-1 ! letzte Notennummer LET g_n%=g_mn% ! Cursor auf Stückende SPUT g_lb$ ! Bild v.Text, Noten reinigen @2_stueck_ganz_zeigen ! 'Geladenes' Stück auf Schirm LET g_fn$=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Stückname ermitteln PRINT AT(1,1);g_fn$;" phys.Nr.:'";i|;"' " ! Info PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein @2_abspielen(1,g_mn%) ! Stück spielen PAUSE g_sp% ! Pause IF g_midi! ! F Midi ein @3_stimme1 ! Sound für Kanal 1 zufällig @3_stimme2 ! Sound für Kanal 2 zufällig ENDIF ! d IF ASC(INKEY$)=27 ! Raus f Escape-Taste LET r!=TRUE ! Rausflag setzen ENDIF ! d EXIT IF r! ! Raus f Abgebrochen ENDIF ! d IF r!=TRUE ! F abgebrochen: LET r!=FALSE ! d @a_alert("Ganz abbrechen?/Ja|Nein",r|) ! d EXIT IF r|=1 ! Raus f ja gewählt: ENDIF ! d EXIT IF r|=1 ! Raus f ja gewählt: NEXT i| ! nächstes Stück ' ............................................................................ ' 4.) S t ü c k w i e d e r h e r s t e l l e n : ' ............................................................................ raus_spielen_gewaehlte: ! Rauslabel IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO m_mn% ! Alle Noten des akt. Stücks durch LET g_n$(n%)=m_n$(n%) ! Stück von Speicherstring in Arbeitsstr NEXT n% ! nächste Note des akt. Stücks ENDIF ! d LET g_n%=m_n% ! Cursor wo er früher war LET g_mn%=m_mn% ! vorher akt. Stück LET g_fn$=name$ ! Name des aktuellen Stücks wiederherst. SPUT bld$ ! Bildschirm wiederherstellen ERASE w!() ! Wahlarray löschen ERASE w|() ! Alphabetnummerarray löschen ERASE m_n$() ! Speicherarray löschen ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 2_hauptfileneuanlegen !_: ' ---------------------------------------------------------------------------- LOCAL ok! ! Flag für Prüfprozedur LOCAL a| ! Wahlvariable für Alertbox LOCAL s% ! Zählvariable LOCAL schirm$ ! Bildschirmspeichervariable LOCAL kl$ ! Klaviaturnegativ ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotogr. PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Gewählt: Hauptfile neuanlegen (ca 40 s)"; PRINT " bisher: '";g_hf$;"'" @3_dfrei(130404,ok!) ! sind noch 130404 Bytes auf Disk frei? IF NOT ok! ! F nicht: GOTO raus_hauptfileneuanlegen ! d ENDIF ! d @a_alert("Achtung! Alle Stücke |im RAM werden gelöscht!/ok!|raus!",a|) IF a|=2 ! F 'raus!' gewählt GOTO raus_hauptfileneuanlegen ! d ENDIF ! d FILESELECT "A:\*.NTN",m$,m$ ! Fileselectbox IF m$="" ! F Abbruch gewählt: GOTO raus_hauptfileneuanlegen ! d ELSE ! sonst: LET g_hf$=RIGHT$(m$,LEN(m$)-3) ! 'A:\' wegschneiden ENDIF ! d PRINT AT(65,1);"'";g_hf$;"'" ! Nochmal Anzeige des Namens ' ............................................................................ LET g_stueck$(0)=STRING$(g_stka|*8,"_")!Inhaltsverz. mit Leerzeichen auffüllen LET g_stueck$(1)=g_stueck$(0) ! Datumteil FOR s%=2 TO g_stka|+1 ! Alle Stücke durch LET g_stueck$(s%)=STRING$(800,"@") ! Mit Leerzeichen auffüllen NEXT s% ! nächstes Stück ' ............................................................................ @a_alert("Gewählt: Hauptfile neuanlegen|Zieldiskette einlegen!|Danach ca 40 Sec. warten!/ok!|raus!",a|) IF a|=2 ! F 'raus!' gewählt @a_alert("Hauptfile ist bereits zerstört!/ok!",a|) @1_fileselectboxfoto ! Fileselectbox fotografieren GOTO raus_hauptfileneuanlegen ! d ENDIF ! d ' ............................................................................ SGET schirm$ ! Bildschirm retten PBOX 0,0,g_bb%-1,g_bh%-1 ! Bildschirm schwarz HIDEM ! Mauspfeil weg OPEN "O",#1,g_hf$ ! Hauptnotenfile öffnen STORE #1,g_stueck$() ! Array abspeichern CLOSE #1 ! File schließen SPUT schirm$ ! Bildschirm wieder herstellen SHOWM ! Mauspfeil zeigen @1_fileselectboxfoto ! Fileselectbox fotografieren ' ............................................................................ raus_hauptfileneuanlegen: ! d PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_dfrei(w%,VAR o!) !_: ' ---------------------------------------------------------------------------- ' Hier wird geprüft, ob noch w% Bytes auf der Diskette 'zu haben' sind. ' ............................................................................ LOCAL a| ! Wahlvariable für's Menü LOCAL f% ! soviel freie Bytes hat's auf der Diskette ' ............................................................................ LET f%=DFREE(0) ! f% freie Bytes gibt's noch auf der Disk. ' ............................................................................ IF f%>=w% ! f mehr als gewünscht oder gleichviel Platz: LET o!=TRUE ! 'Alles ok!' übergeben ELSE ! f weniger als gewünscht Platz auf Disk: @a_alert("Es sind frei:'"+STR$(f%)+"'|Es braucht aber:'"+STR$(w%)+"'/ok!",a|) ENDIF ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_hauptfile_laden !_: ' ---------------------------------------------------------------------------- LOCAL dummy| ! Dummy für Alertbox LOCAL dummy% ! Dummy für RECALL-Befehl LOCAL m$ ! Speicher für Filename LOCAL b$ ! Bildspeicher ' ............................................................................ SGET b$ ! Bild retten SPUT g_lb$ ! Löschbildschirm PRINT AT(1,1);"Gewählt: Hauptfile laden (ca 15 Sek.)"; PRINT " bisher: '";g_hf$;"'" ' ............................................................................ FILESELECT "A:\*.NTN",m$,m$ ! Fileselectbox ' ............................................................................ IF m$="" OR NOT EXIST(m$) ! F Abbruch gewählt: GOTO raus_2_hauptfile_laden ! d ELSE ! sonst: LET g_hf$=RIGHT$(m$,LEN(m$)-3) ! 'A:\' wegschneiden ENDIF ! d PRINT AT(65,1);"'";g_hf$;"'" ! Nochmal Anzeige des Namens ' ............................................................................ OPEN "I",#1,g_hf$ ! Hauptnotenfile öffnen RECALL #1,g_stueck$(),-1,dummy% ! Array laden CLOSE #1 ! File schließen ' ............................................................................ @1_fileselectboxfoto ! Fileselectbox fotografieren ' ............................................................................ raus_2_hauptfile_laden: ! d SPUT b$ ! Bild wiederherstellen PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_save_hauptfile !_: ' ---------------------------------------------------------------------------- LOCAL ok! ! Flag für Prüfprozedur LOCAL m$ ! Speicher für Filename LOCAL schirm$ ! Bildschirmspeichervariable LOCAL kl$ ! Klaviaturnegativ ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotogr. PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Gewählt: Hauptfile abspeichern (ca 40 s)"; PRINT " bisher: '";g_hf$;"'" @3_dfrei(130404,ok!) ! sind noch 130404 Bytes auf Disk frei? IF ok!=FALSE ! F nicht: GOTO raus_save_hauptfile ! d ENDIF ! d ' ............................................................................ FILESELECT "A:\*.NTN",m$,m$ ! Fileselectbox ' ............................................................................ IF m$="" ! F Abbruch gewählt: GOTO raus_save_hauptfile ! d ELSE ! sonst: LET g_hf$=RIGHT$(m$,LEN(m$)-3) ! 'A:\' wegschneiden ENDIF ! d PRINT AT(65,1);"'";g_hf$;"'" ! Nochmal Anzeige des Namens ' ............................................................................ SGET schirm$ ! Bildschirm retten PBOX 0,0,g_bb%-1,g_bh%-1 ! Bildschirm schwarz HIDEM ! Mauspfeil weg ' ............................................................................ OPEN "O",#1,g_hf$ ! Hauptnotenfile öffnen STORE #1,g_stueck$() ! Array abspeichern CLOSE #1 ! File schließen ' ............................................................................ SPUT schirm$ ! Bildschirm wieder herstellen SHOWM ! Mauspfeil zeigen ' ............................................................................ raus_save_hauptfile: ! d PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_file_loeschen !_: ' ---------------------------------------------------------------------------- LOCAL a| ! für Alertbox LOCAL m$ ! Speicher für Filename LOCAL kl$ ! Klaviaturnegativ ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotogr. PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Gewählt: File löschen!"! Info über gewählten Befehl ' ............................................................................ nochmal_file_loeschen: ! Wiederhol-Label FILESELECT "A:\*.*",m$,m$ ! Fileselectbox ' ............................................................................ IF m$="" OR NOT EXIST(m$) ! F Abbruch gewählt: GOTO raus_file_loeschen ! d ELSE ! sonst: LET m$=RIGHT$(m$,LEN(m$)-3) ! 'A:\' wegschneiden ENDIF ! d @a_alert("Gelöscht wird: '"+m$+"' !/ok!|raus!",a|) IF a|=2 ! F Abbruch gewählt: GOTO raus_file_loeschen ! d ENDIF ! d PRINT AT(40,1);"'";m$;"' " ! Nochmal Anzeige des Namens ' ............................................................................ KILL m$ ! d ' ............................................................................ GOTO nochmal_file_loeschen ! Kreislauf, f viel gelöscht werden muß ' ............................................................................ raus_file_loeschen: ! d PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_rename_file !_: ' ---------------------------------------------------------------------------- ' Hier wird ein File auf der Diskette umbenannt. ' ---------------------------------------------------------------------------- LOCAL ok! ! Flag für Prüfprozedur LOCAL a| ! für Alertbox LOCAL m$ ! Speicher für Filename LOCAL neu$ ! Speicher für neuen Namen LOCAL kl$ ! Klaviaturnegativ ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotogr. PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Gewählt: File umbenennen! Jetzt: Umzubenennendes File anwählen!";! Info über gewählten Befehl ' ............................................................................ FILESELECT "A:\*.*",m$,m$ ! Fileselectbox ' ............................................................................ IF m$="" OR NOT EXIST(m$) ! F Abbruch gewählt: GOTO raus_rename_file ! d ELSE ! sonst: LET m$=RIGHT$(m$,LEN(m$)-3) ! 'A:\' wegschneiden ENDIF ! d ' ............................................................................ nochmal_rename_file: ! Wiederhol-Label PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1); ! Cursor positionieren PRINT " Neuer Name: "; ! Input-Info und Input platzieren INPUT neu$ ! Eingabe des neuen Namens IF neu$="-1" ! F Abbruch gewählt: GOTO raus_rename_file ! d ENDIF ! d @3_pruef(neu$,ok!) ! Überprüfung der Eingabe IF NOT ok! ! F nicht ok: IF LEN(neu$)>12 ! F zu lang LET neu$=LEFT$(neu$,12) ! zurechtstutzen ENDIF ! d @a_alert("'"+neu$+"' ist unmöglicher Dateiname!/ok!|raus!",a|) IF a|=1 ! F Einsicht: GOTO nochmal_rename_file ! Kreislauf ELSE ! F Abbruch gewünscht: GOTO raus_rename_file ! d ENDIF ! d ENDIF ! d ' ............................................................................ @a_alert("Geändert wird: '"+m$+"'|zu: '"+neu$+"'!/ok!|raus!",a|) IF a|=2 ! F Abbruch gewählt: GOTO raus_rename_file ! d ENDIF ! d PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Jetzt wird umbenannt: alt:'";m$;"' neu:'";neu$;"'" ! Nochmal Anzeige der Namen ' ............................................................................ RENAME m$ AS neu$ ! File umbenennen ' ............................................................................ raus_rename_file: ! d PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_pruef(n$,VAR o!) !_: ' ---------------------------------------------------------------------------- ' n$ ! zu überprüfender Dateiname ' o! ! =-1 falls Dateiname ok LOCAL fehler! ! Flag für 'Fehler gefunden' LOCAL i| ! Zähler für Zeichen LOCAL asc| ! Ascii-Wert des aktuellen Zeichens LOCAL ext$ ! Extension LOCAL name$ ! Filename ohne Extension LOCAL pkt$ ! Punkt zwischen Filename und Extension ' ............................................................................ ' ! Dateiname sollte z.B. so aussehen:'NAME.EXT' ' ............................................................................ IF LEN(n$)<5 ! '.EXT' + ein Zeichen brauchts mindestens LET fehler!=TRUE ! Fehler gefunden GOTO raus_pruef ! d ENDIF ! d ' ............................................................................ LET ext$=RIGHT$(n$,3) ! Extension ausschneiden LET name$=LEFT$(n$,LEN(n$)-4) ! Name ausschneiden LET pkt$=LEFT$(RIGHT$(n$,4),1)! Punkt ausschneiden ' ............................................................................ IF pkt$<>"." ! F hier kein Punkt zu sehen: LET fehler!=TRUE ! Fehler gefunden GOTO raus_pruef ! d ENDIF ! d ' ............................................................................ FOR i|=1 TO LEN(name$) ! Name durch LET asc|=ASC(MID$(name$,i|,1)) ! Ascci-wert festhalten IF asc|<65 OR asc|>90 ! F außerhalb großer Buchstaben IF NOT (asc|>47 AND asc|<58) ! F keine Ziffer: LET fehler!=TRUE ! Fehler gefunden ENDIF ! d ENDIF ! d NEXT i| ! nächster Buchstabe des Namens ' ............................................................................ FOR i|=1 TO LEN(ext$) ! Extension durch LET asc|=ASC(MID$(ext$,i|,1)) ! Ascci-wert festhalten IF asc|<65 OR asc|>91 ! F außerhalb großer Buchstaben IF NOT (asc|>47 AND asc|<58) ! F keine Ziffer: LET fehler!=TRUE ! Fehler gefunden ENDIF ! d ENDIF ! d NEXT i| ! nächster Buchstabe des Extensions ' ............................................................................ raus_pruef: ! d IF NOT fehler! ! F keinen Fehler gefunden LET o!=TRUE ! Rückgabeparameter auf 'Alles ok' setzen ENDIF ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_inhverz_drucken !_: ' ---------------------------------------------------------------------------- ' Hier wird das Inhaltsverzeichnis des Hauptfiles gedruckt, mit Datum, ' physikalischer und alphabetischer Stücknummer und zwar zweispaltig in ' Superscript. ' ---------------------------------------------------------------------------- LOCAL i| ! Zähler für die einzelnen Stücke LOCAL schirm$ ! Bildschirmspeichervariable DIM i$(g_stka|) ! Array für die 160 Textzeilen ' ............................................................................ ' 1.) T e x t z e i l e n k o n s t r u i e r e n : ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Stücke durch, physikalisch LET name$=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Stückname ermitteln LET datu$=MID$(g_stueck$(1),(i|-1)*8+1,8) ! Datum ermitteln LET alph$=STRING$(3-LEN(STR$(i|)),"0")+STR$(i|) ! Alphabetische Stücknummer LET i$(i|)=name$+" | "+datu$+" | "+alph$+" | " ! Zeile für i|-tes Stück NEXT i| ! nächstes Stück ' ............................................................................ QSORT i$(),g_stka|+1 ! Sortieren, alphabetisch ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Stücke durch, alphabetisch LET phys$=STRING$(3-LEN(STR$(i|)),"0")+STR$(i|) ! physikalische Stücknummer LET i$(i|)=i$(i|)+phys$ ! physikalische Stücknummer dranhängen NEXT i| ! nächstes Stück ' ............................................................................ FOR i|=1 TO g_stka|/2 ! Alle Stücke durch, alphabetisch LET i$(i|)=i$(i|)+" "+i$(i|+80) ! beide Spalten in eine Zeile NEXT i| ! nächstes Stück ' ............................................................................ ' 2.) A u s d r u c k e n ' ............................................................................ @a_alert("Wirklich drucken?/Ja|Nein",r|) ! d IF r|=2 ! F Abbruch gewählt: GOTO raus_inhverz ! raus ENDIF ! d ' ............................................................................ SGET schirm$ ! Bildschirm retten PBOX 0,0,g_bb%-1,g_bh%-1 ! Bildschirm schwarz HIDEM ! Mauspfeil weg ' ............................................................................ LPRINT CHR$(27);CHR$(64); ! resets the printer LPRINT CHR$(27);CHR$(83);CHR$(0); ! selects superscripts ' LPRINT CHR$(27);CHR$(69); ! selects emphasized printing LPRINT CHR$(27);CHR$(51);CHR$(24); ! sets line spacing to n/216 inch LPRINT CHR$(27);CHR$(108);CHR$(10); ! stets the left margin ' ............................................................................ FOR i|=1 TO g_stka|/2 ! Alle Stücke durch, alphabetisch LPRINT i$(i|) ! Doppelspaltenzeile drucken, also Infos ' ! für i|-tes u n d i|+80-tes Stück. NEXT i| ! nächstes Stück ' ............................................................................ SPUT schirm$ ! Bildschirm wieder herstellen SHOWM ! Mauspfeil zeigen ' ............................................................................ raus_inhverz: ! Rauslabel ERASE i$() ! Array für die 160 Textzeilen löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_drucken_ab_x_alle !_: ' ---------------------------------------------------------------------------- ' Notentexte werden gedruckt; alle Stücke ab der x-ten Stelle im alphabetisch ' geordneten Inhaltsverzeichnis. Außer Punkt 2.) und Punkt 3.) stimmt diese ' Prozedur so ziemlich mit der '2_drucken_gewaehlt' überein. ' ---------------------------------------------------------------------------- LOCAL r! ! Rausvariable 1 LOCAL r| ! Rausvariable 2 LOCAL i| ! Stückzähler LOCAL m_mn% ! Merker für letzte Note LOCAL m_n% ! Merker für Cursorposition LOCAL x% ! Beginnummer LOCAL a$ ! Zwischenspeicher für Notencode LOCAL s$ ! Abkürzungsvariable LOCAL bld$ ! Bildschirmrettungsnegativ LOCAL name$ ! Name des aktuellen Stücks DIM w!(g_stka|) ! Auswahlarray, Eintrag=-1,f entspr. ' ! Stück ausgewählt worden ist. DIM w|(g_stka|) ! Alphabetnummerarray löschen DIM m_n$(g_os%) ! Zwischenspeicher für akt. Stück DIM a$(g_stka|) ! Menüeintragsfelderarray dim. DIM a%(g_stka|) ! Nummerierungsarray dim. ' ............................................................................ ' 1.) l e t z t e s S t ü c k r e t t e n : ' ............................................................................ SGET bld$ ! Bildschirm retten LET name$=g_fn$ ! Name des aktuellen Stücks retten LET m_mn%=g_mn% ! letzte Note des akt. Stücks merken LET m_n%=g_n% ! Cursorposition des akt. Stücks merken IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO g_mn% ! Alle Noten des akt. Stücks durch LET m_n$(n%)=g_n$(n%) ! Stück in Speicherstring NEXT n% ! nächste Note des akt. Stücks ENDIF ! d ' ............................................................................ ' 2.) V o r b e r e i t u n g e n : ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus PRINT AT(1,1);"Ab welcher Stelle im Inhaltsverz. soll gedruckt werden (raus:'-1') "; INPUT x% ! Beginnummer IF x%<1 OR x%>g_stka| ! F Abbruch gewählt GOTO raus_drucken_ab_x_alle ! uverrichteter Dinge raus ENDIF ! d ' ............................................................................ ' 3.) D r u c k b i l d e r h e r s t e l l e n : ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Menüeinträge durch LET a$(i|)=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Ins Menüeintragsfeld kopieren LET a%(i|)=i| ! Nummerierungsarrayeintrag NEXT i| ! nächster Menüeintrag ' ............................................................................ QSORT a$(),g_stka|+1,a%() ! Sortieren, alphabetisch, in ' ! a%() wird die physikalische ' ! Nr. mitsortiert. ' ............................................................................ FOR i|=x% TO g_stka| ! Alle Menüeinträge ab x| durch EXIT IF LEFT$(g_stueck$(a%(i|)+1),4)="@@@@" ! raus f leeres Stück ' ! in alphabetischer Reihenfolge @3_dr_st(a%(i|),i|,r!) ! Eine Ebene weiter zum Drucken IF r!=TRUE ! F abgebrochen: LET r!=FALSE ! d @a_alert("Ganz abbrechen?/Ja|Nein",r|) ! d EXIT IF r|=1 ! Raus f ja gewählt: ENDIF ! d EXIT IF r|=1 ! Raus f ja gewählt: NEXT i| ! nächster Menüeintrag ' ............................................................................ ' 4.) S t ü c k w i e d e r h e r s t e l l e n : ' ............................................................................ raus_drucken_ab_x_alle: ! Rauslabel IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO m_mn% ! Alle Noten des akt. Stücks durch LET g_n$(n%)=m_n$(n%) ! Stück von Speicherstring in Arbeitsstr NEXT n% ! nächste Note des akt. Stücks ENDIF ! d LET g_fn$=name$ ! Name des aktuellen Stücks wiederherst. LET g_n%=m_n% ! Cursor wo er früher war LET g_mn%=m_mn% ! vorher akt. Stück SPUT bld$ ! Bildschirm wiederherstellen ERASE w!() ! Wahlarray löschen ERASE w|() ! Alphabetnummerarray löschen ERASE m_n$() ! Speicherarray löschen ERASE a$() ! Menüeintragsarray löschen ERASE a%() ! Nummerierungsarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_spielen_ab_x_alle !_: ' ---------------------------------------------------------------------------- ' Notentexte werden gespielt; alle Stücke ab der x-ten Stelle im alphabetisch ' geordneten Inhaltsverzeichnis. Außer Punkt 2.) und Punkt 3.) stimmt diese ' Prozedur so ziemlich mit der '2_drucken_gewaehlt' überein. ' ---------------------------------------------------------------------------- LOCAL r! ! Rausvariable 1 LOCAL r| ! Rausvariable 2 LOCAL i| ! Stückzähler LOCAL m_mn% ! Merker für letzte Note LOCAL m_n% ! Merker für Cursorposition LOCAL x% ! Beginnummer LOCAL a$ ! Zwischenspeicher für Notencode LOCAL s$ ! Abkürzungsvariable LOCAL bld$ ! Bildschirmrettungsnegativ LOCAL name$ ! Namensretter DIM w!(g_stka|) ! Auswahlarray, Eintrag=-1,f entspr. ' ! Stück ausgewählt worden ist. DIM w|(g_stka|) ! Alphabetnummerarray löschen DIM m_n$(g_os%) ! Zwischenspeicher für akt. Stück DIM a$(g_stka|) ! Menüeintragsfelderarray dim. DIM a%(g_stka|) ! Nummerierungsarray dim. ' ............................................................................ ' 1.) l e t z t e s S t ü c k r e t t e n : ' ............................................................................ SGET bld$ ! Bildschirm retten LET m_mn%=g_mn% ! letzte Note des akt. Stücks merken LET m_n%=g_n% ! Cursorposition des akt. Stücks merken LET name$=g_fn$ ! Name des aktuellen Stücks retten IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO g_mn% ! Alle Noten des akt. Stücks durch LET m_n$(n%)=g_n$(n%) ! Stück in Speicherstring NEXT n% ! nächste Note des akt. Stücks ENDIF ! d ' ............................................................................ ' 2.) V o r b e r e i t u n g e n : ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus PRINT AT(1,1);"Ab welcher Stelle im Inhaltsverz. soll gespielt werden (raus:'-1') "; INPUT x% ! Beginnummer IF x%<1 OR x%>g_stka| ! F Abbruch gewählt GOTO raus_spielen_ab_x_alle ! uverrichteter Dinge raus ENDIF ! d ' ............................................................................ ' 3.) S p i e l b i l d e r h e r s t e l l e n : ' ............................................................................ FOR i|=1 TO g_stka| ! Alle Menüeinträge durch LET a$(i|)=MID$(g_stueck$(0),(i|-1)*8+1,8) ! Ins Menüeintragsfeld kopieren LET a%(i|)=i| ! Nummerierungsarrayeintrag NEXT i| ! nächster Menüeintrag ' ............................................................................ QSORT a$(),g_stka|+1,a%() ! Sortieren, alphabetisch, in ' ! a%() wird die physikalische ' ! Nr. mitsortiert. ' ............................................................................ FOR i|=x% TO g_stka| ! Alle Menüeinträge ab x| durch ' ! in alphabetischer Reihenfolge LET s$=g_stueck$(a%(i|)+1) ! Stück kopieren EXIT IF LEFT$(s$,4)="@@@@" ! Raus f leeres Stück FOR j|=1 TO g_os% ! Alle Noten des i|-ten St.durch LET g_n$(j|)=MID$(s$,(j|-1)*4+1,4) ! ins aktuelle Stück kopieren EXIT IF g_n$(j|)="@@@@" ! F leere Note NEXT j| ! nächste Note LET g_mn%=j|-1 ! letzte Notennummer LET g_n%=g_mn% ! Cursor auf Stückende SPUT g_lb$ ! Bild v.Text und Noten reinigen @2_stueck_ganz_zeigen ! 'Geladenes' Stück auf Schirm PRINT AT(1,1);a$(i|);" alph.Nr.:'";i|;"' phys.Nr.:'";a%(i|);"' " ! Info PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein @2_abspielen(1,g_mn%) ! Stück spielen PAUSE g_sp% ! Pause IF g_midi! ! F Midi ein @3_stimme1 ! Sound für Kanal 1 zufällig @3_stimme2 ! Sound für Kanal 2 zufällig ENDIF ! d EXIT IF ASC(INKEY$)=27 ! Raus f Escape-Taste NEXT i| ! nächster Menüeintrag ' ............................................................................ ' 4.) S t ü c k w i e d e r h e r s t e l l e n : ' ............................................................................ raus_spielen_ab_x_alle: ! Rauslabel SPUT g_lb$ ! Bild v.Text und Noten reinigen IF m_mn%<>0 ! F vor Druckbefehl Stück im Speicher: FOR n%=1 TO m_mn% ! Alle Noten des akt. Stücks durch LET g_n$(n%)=m_n$(n%) ! Stück von Speicherstring in Arbeitsstr NEXT n% ! nächste Note des akt. Stücks ENDIF ! d LET g_fn$=name$ ! Name des aktuellen Stücks wiederherst. LET g_n%=m_n% ! Cursor wo er früher war LET g_mn%=m_mn% ! vorher akt. Stück SPUT bld$ ! Bildschirm wiederherstellen ERASE w!() ! Wahlarray löschen ERASE w|() ! Alphabetnummerarray löschen ERASE m_n$() ! Speicherarray löschen ERASE a$() ! Menüeintragsarray löschen ERASE a%() ! Nummerierungsarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_stimme1 !_: ' ---------------------------------------------------------------------------- REPEAT ! Zufallsschleife LET i=RANDOM(28) ! zufällig wählen UNTIL i=0 OR i=2 OR i=3 OR i=4 OR i=10 OR i=13 OR i=20 OR i=25 OR i=26 OR i=27 OUT 3,192,i ! Sound für Kanal 1 einstellen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_stimme2 !_: ' ---------------------------------------------------------------------------- REPEAT ! Zufallsschleife LET i=RANDOM(30) ! zufällig wählen UNTIL i=7 OR i=8 OR i=15 OR i=18 OR i=23 OR i=24 OR i=29 OUT 3,193,i ! Sound für Kanal 2 einstellen ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 1_blockmark(i|) !_: ' ---------------------------------------------------------------------------- ' i| ! =1: Blockanfang soll gesetzt werden, =2: Blockende ' =3: Blockmarken löschen LOCAL alt_ble% ! altes Blockende merken ' ---------------------------------------------------------------------------- IF g_n%>g_mn% AND g_mn%>1 ! F Endschreibmodus eingeschaltet,ausschalten: PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus LET g_n%=g_mn% ! Cursor auf Notentextende setzen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein ENDIF ! d ' ............................................................................ IF g_bla%=0 AND g_ble%=0 AND i|=1 ! 1.) F Blockm nicht gesetzt: Blockanfang ' .......................................................................... ' ! Blockanfang: IF g_n%<g_mn%-3 AND i|=1 ! F Block mindestens 3 Noten lang werden kann: LET g_bla%=g_n% ! Blockanfang setzen LET g_ble%=g_mn% ! Blockende auf Notentextende setzen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus IF g_mn%=g_os% ! F 200 Noten LET g_n%=g_mn% ! Cursor auf letzte Note ELSE ! sonst: LET g_n%=g_mn%+1 ! Endschreibmodus ein, d.h. Cursor>letzte Note ENDIF ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein @2_invers(g_bla%,g_mn%) ! Ab Note g_bla% Rest des Notenstücks invers ENDIF ! d ' .......................................................................... ELSE IF g_bla%<>0 AND i|=3 ! 2.) F Blockanf.gesetzt: Blockmarken löschen ' .......................................................................... @2_invers(g_bla%,g_ble%) ! Blockmarkierung löschen LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen ' .......................................................................... raus_blockmark: ! d ' .......................................................................... ' F Block >= 3 Noten lang und Blanf. gesetzt und Curs<Blende und i|=2: ELSE IF g_n%-g_bla%>=3 AND g_bla%<>0 AND g_n%<g_ble% AND i|=2 ! 3.) Blockende LET alt_ble%=g_ble% ! altes Blockende merken LET g_ble%=g_n% ! Blockende setzen PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus IF g_mn%=g_os% ! F 200 Noten LET g_n%=g_mn% ! Cursor auf letzte Note ELSE ! sonst: LET g_n%=g_mn%+1 ! Cursorpos hinter Textende (Endschreibmodus) ENDIF ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein @2_invers(g_ble%+1,alt_ble%) ! Ab Note g_ble%+1 Rest invers, da bisher: ' ! ab Note g_bla% Rest invers, ist jetzt der ' ! Blockbereich vollständig markiert ' .......................................................................... ENDIF ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 2_invers(a%,b%) !_: ' ---------------------------------------------------------------------------- ' Diese Prozedur invertiert den Notentext von einschließlich Note a% bis e.b% ' und zwar zwischen der 1. und der 5. Notenlinie. Würde die ganze Zeile in- ' vertiert, könnte man den Cursor vom Blockbereich am Rand nicht mehr unter- ' scheiden. ' Man muß 2 Fälle betrachten: ' 1.) Die Noten a% und b% liegen in derselben Zeile: ' Also ist von einschl. a% bis einschl. b% ein Rechteck zu invertieren. ' 2.) Die Note b% liegt in einer Zeile unterhalb der von a%, dann: ' a) Zeile von a% ab a% einschließlich invertieren ' b) Zeile von b% bis b% einschließlich invertieren ' c) Zeilen dazwischen - sofern vorhanden - invertieren ' ---------------------------------------------------------------------------- LOCAL za| ! Zeile von a% LOCAL zb| ! Zeile von b% LOCAL aktz| ! akt. Zeile der Zwischenzeilenschleife (2.c) LOCAL o| ! Diff. 1.linie v.ob. Zlnrnd (s.a.'Notenlinien') LOCAL u| ! o|+Diff. 5.Notenlinie von unterem Zeilenrand LOCAL a$ ! Negativstring ' ---------------------------------------------------------------------------- IF a%>b% ! F plödsinnige Übergabewerte: GOTO raus_invers ! hau ab! ENDIF ! d ' ............................................................................ LET za|=TRUNC((a%-1)/g_npz|)+1! Zeile von a%=tr.(akt.Note-1/Noten proZeile)+1 LET zb|=TRUNC((b%-1)/g_npz|)+1! Zeile von b%=tr.(akt.Note-1/Noten proZeile)+1 LET o|=30 ! Pos. 1.Notenlinie: g_y%(?)+n1y| LET u|=o|+19 ! o|+5.Notenlinie (Diff.von unterem Zeilenrand) ' ............................................................................ IF za|=zb| ! 1.) a% und b% liegen in derselben Zeile: ' .......................................................................... LET x1%=g_x%(a%) ! links = Start-x-Koord. von Note a% LET y1%=g_y%(a%)+o| ! oben = Start-y-Koord. von Note a% LET x2%=g_x%(b%)+g_nb|-1 ! rechts= Start-x-Koord. Note b% + Notenbr.-1Pkt LET y2%=y1%+g_nzlh|-2-u| ! unten = oben + Zeilenhöhe - 2 (-2=Rand) GET x1%,y1%,x2%,y2%,a$ ! Bereich fotografieren PUT x1%,y1%,a$,8 ! Bereich invertiert ausgeben ' .......................................................................... ELSE IF za|<zb| ! 2.) a% und b% liegen in verschiedenen Zeilen: ' .......................................................................... ' ! a) Zeile von a% ab a% einschl. invertieren: ' .......................................................................... LET x1%=g_x%(a%) ! links = Start-x-Koord. von Note a% LET y1%=g_y%(a%)+o| ! oben = Start-y-Koord. von Note a% LET x2%=g_bb%-1 ! rechts= Bildschirmbreite - 1 Punkt LET y2%=y1%+g_nzlh|-2-u| ! unten = oben + Zeilenhöhe - 2 (-2=Rand) GET x1%,y1%,x2%,y2%,a$ ! Bereich fotografieren PUT x1%,y1%,a$,8 ! Bereich invertiert ausgeben ' .......................................................................... ' ! b) Zeile von b% bis b% einschl. invertieren: ' .......................................................................... LET x1%=0 ! links = 0 LET y1%=g_y%(b%)+o| ! oben = Start-y-Koord. von Note b% LET x2%=g_x%(b%)+g_nb|-1 ! rechts= Start-x-K. b% + Notenbreite - 1 Punkt LET y2%=y1%+g_nzlh|-2-u| ! unten = oben + Zeilenhöhe - 2 (-2=Rand) GET x1%,y1%,x2%,y2%,a$ ! Bereich fotografieren PUT x1%,y1%,a$,8 ! Bereich invertiert ausgeben ' .......................................................................... ' ! c) Zeilen dazw.-falls vorhanden-invertieren: ' .......................................................................... LET aktz|=za|+1 ! Startzeile sei Zeile unter der von der Note a% WHILE aktz|<zb| ! Solange aktz| echt zwischen za| und zb| liegt: LET n%=aktz|*g_npz| ! letzteNote in akt. Zeile=akt.Zle*NotenproZle+1 LET x1%=0 ! links = 0 LET y1%=g_y%(n%)+o| ! oben = Start-y-Koord. von Note n% LET x2%=g_bb%-1 ! rechts= Bildschirmbreite - 1 Punkt LET y2%=y1%+g_nzlh|-2-u| ! unten = oben + Zeilenhöhe - 2 (-2=Rand) GET x1%,y1%,x2%,y2%,a$ ! Bereich fotografieren PUT x1%,y1%,a$,8 ! Bereich invertiert ausgeben INC aktz| ! Aktuelle Zeile um eins erhöhen WEND ! Schleifenende ' .......................................................................... ENDIF ! EFU a%,b% liegen in gleichen/versch. Zeilen ' PRINT AT(1,1);"a%,b%,g_bla%,g_ble%,za|,zb|,aktz|" ' PRINT AT(1,2);a%,b%,g_bla%,g_ble%,za|,zb|,aktz| ' STOP ' ............................................................................ raus_invers: ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_block_kopieren !_: ' ---------------------------------------------------------------------------- ' Der Blockbereich wird an die Stelle vor den Cursor kopiert. ' ---------------------------------------------------------------------------- LOCAL n% ! Notenpositionszähler LOCAL i% ! Zähler für Zwischenspeicherfüllschleife LOCAL bl_l% ! Blocklänge ' ............................................................................ LET bl_l%=g_ble%-g_bla%+1 ! Blocklänge in Noten (einschl. Blockgrenzen) ' ............................................................................ ' 1.) Raus bei fehlerhaften Voraussetzungen: ' ............................................................................ IF g_mn%+bl_l%>g_os% ! F neuer Text zu groß würde: GOTO raus_block_kopieren ! raus ENDIF ! d IF g_n%>g_bla% AND g_n%<g_ble%! F Cursor innerhalb vom Block: GOTO raus_block_kopieren ! raus ENDIF ! d IF g_bla%=0 OR g_ble%=0 ! F Blockanfang oder - ende nicht gesetzt: GOTO raus_block_kopieren ! raus ENDIF ! d DIM n$(bl_l%) ! Zwischenspeicherarray dimensionieren: Erst ' ! nachdem sichergestellt ist, daß Block fertig. ' ............................................................................ ' 2. Blockbereich in einen Zwischenspeicher: ' ............................................................................ LET n%=bl_l%+1 ! Zähler für Zwischenspeicherarray setzen FOR i%=g_bla% TO g_ble% ! Den ganzen Block einschl. Blockgrenzen durch: DEC n% ! Normalen Zähler -1, denn von oben nach unten: LET n$(n%)=g_n$(i%) ! Zwischenspeicherarray füllen NEXT i% ! nächste Note im Block ' ............................................................................ ' 3. Den Inhalt des Zwischenspeichers an Position n% einfügen: ' ............................................................................ FOR n%=1 TO bl_l% ! den ganzen Block nochmal durch INSERT g_n$(g_n%)=n$(n%) ! Zwischenspeicherarray an Position n% einfügen NEXT n% ! nächste Note im Zwischenspeicherarray ' ............................................................................ ' 4. Den veränderten Text darstellen ' ............................................................................ LET g_mn%=g_mn%+bl_l% ! Neue Endnotennummer festsetzen SPUT g_lb$ ! Bild von Noten reinigen (Löschbild) @2_stueck_ganz_zeigen ! Geladenes Stück auf Bildschirm IF g_mn%=g_os% ! F 200 Noten LET g_n%=g_mn% ! Cursor auf letzte Note ELSE ! d LET g_n%=g_mn%+1 ! Notencursor hinter Stückende: erst hier, ' ! da in 'geladenes_stueck' for-Schleife ENDIF ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen ' ............................................................................ raus_block_kopieren: ! d ERASE n$() ! Zwischenspeicherarray löschen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_block_loeschen !_: ' ---------------------------------------------------------------------------- ' Die Noten im Blockbereich werden gelöscht. Der Befehl muß bestätigt werden. ' ---------------------------------------------------------------------------- LOCAL a| ! Wahlvariable für Alertbox LOCAL n% ! Notenpositionszähler LOCAL bl_l% ! Blocklänge ' ............................................................................ IF g_bla%<>0 AND g_ble%<>0 ! F Block bereits vollständig markiert @a_alert("Wirklich löschen?/Ja|Nein",a|) IF a|=2 ! Nein gewählt: GOTO raus_block_loeschen ! raus ENDIF ! d @a_undostueck ! Stück vorsichtshalber in Undoarray kopieren ENDIF ! d ' ............................................................................ IF g_bla%=1 AND g_ble%=g_mn% ! F ganzes Stück gelöscht werden soll: SPUT g_lb$ ! Bild von Noten reinigen (Löschbild) LET g_n%=1 ! Endschreibmodus ein, zusammen mit: LET g_mn%=0 ! Endschreibmodus ein PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen GOTO raus_block_loeschen ! raus ELSE IF g_bla%=0 OR g_ble%=0 ! F Blockanfang oder - ende nicht gesetzt: GOTO raus_block_loeschen ! raus ENDIF ! d ' ............................................................................ ' ! den ganzen Block durch einschl. Blockgrenzen: LET n%=g_ble% ! Hinten am Blockende (einschl.) anfangen REPEAT ! 'FOR n%=g_ble% DOWNTO g_bla%' - Ersatzschleife ' PRINT AT(1,1);"Bl.anf.:'";g_bla%;"' Bl.end.:'";g_ble%;"' nächste Löschnote: g_n$(";n%;")='";g_n$(n%);"' g_mn%='";g_mn%;"' " DELETE g_n$(n%) ! Note innerhalb des Blocks löschen DEC n% ! nächste Note innerhalb des Blocks UNTIL n%=g_bla%-1 ! Raus, f Blockanfang einschließlich gekillt ' ............................................................................ LET bl_l%=g_ble%-g_bla%+1 ! Blocklänge in Noten (einschl. Blockgrenzen) LET g_mn%=g_mn%-bl_l% ! Neue Endnotennummer festsetzen SPUT g_lb$ ! Bild von Noten reinigen (Löschbild) @2_stueck_ganz_zeigen ! Geladenes Stück auf Bildschirm LET g_n%=g_mn% ! Notencursor auf Stückende: erst hier, ' ! da in 'geladenes_stueck' for-Schleife IF g_n%=0 ! F Keine Note mehr vorhanden (auch g_mn%=0) LET g_n%=1 ! Endschreibmodus ein ENDIF ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen ' ............................................................................ raus_block_loeschen: ! d ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_bl_faehnchen(v!) !_: ' ---------------------------------------------------------------------------- ' Ein Fähnchen wird der aktuellen Note hinzugefügt oder weggennommen, was ' im 1. Teil festgestellt wird. Danach werden im 2. Teil die Ober- ' und Untergrenzen der Fähnchenanzahl einzelner Noten im Block ermittelt. ' Falls mehr oder weniger Fähnchen gewünscht werden, als vom Programm her ' überhaupt möglich, wird im 3. Teil zum Prozedurende verzweigt. Im 4. Teil ' wird dann die Note wie gewünscht verändert und im 5. Teil neu dargestellt. ' ---------------------------------------------------------------------------- ' v! ! =-1 für: ein Fähnchen weniger LOCAL b| ! Fähnchenanzahl irgendeiner Note im Block LOCAL max_b| ! maximale Fähnchenanzahl im Block LOCAL min_b| ! minimale Fähnchenanzahl im Block LOCAL n% ! Notennrzähler für Blockschleife LOCAL f% ! Fähnchendiff. ganzzahlig ' ............................................................................ PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus ' ............................................................................ ' 1. Gewühnschte Fähnchenanzahldifferenz ermitteln: ' ............................................................................ IF v!=-1 ! F ein Fähnchen weniger verlangt LET f%=-1 ! Differenz = -1 ELSE ! F ein Fähnchen mehr verlangt LET f%=1 ! Differenz = +1 ENDIF ! d ' ............................................................................ ' 2. Minimale und maximale Fähnchenanzahl im Block ermitteln: ' ............................................................................ LET min_b|=3 ! Minimum = höchstmögliche Fähnchenanzahl FOR n%=g_bla% TO g_ble% ! den ganzen Block einschl. Grenzen durch: LET b|=VAL(MID$(g_n$(n%),2,1)) ! Periode der aktuellen Blocknote IF b|>max_b| ! F akt. Fähnchenanz.>max.Fähnchenanz. LET max_b|=b| ! maximale Fähnchenanz. neu setzen ENDIF ! d IF b|<min_b| ! F akt. Fähnchenanz.<min.Fähnchenanz. LET min_b|=b| ! minimale Fähnchenanz. neu setzen ENDIF ! d NEXT n% ! nächste Note innerhalb des Blocks ' ............................................................................ ' 3.) Raus, falls gewünschte Periodendauer > 1/4 oder < 1/32 sein soll: ' ............................................................................ IF min_b|+f%<0 ! F weniger als null Fähnchen gewünscht: PRINT AT(1,1);"zu lang!" ! Fehlermeldung PAUSE 40 ! Zeit zum Lesen GOTO raus_bl_faehnchen ! d ENDIF ! d IF max_b|+f%>3 ! F mehr als vier Fähnchen gewünscht: PRINT AT(1,1);"zu kurz!" ! Fehlermeldung PAUSE 40 ! Zeit zum Lesen GOTO raus_bl_faehnchen ! d ENDIF ! d ' ............................................................................ ' 4.) Fähnchenveränderschleife ' ............................................................................ FOR n%=g_bla% TO g_ble% ! den ganzen Block einschl. Grenzen durch: LET b|=VAL(MID$(g_n$(n%),2,1)) ! Periode der aktuellen Blocknote MID$(g_n$(n%),2,1)=STR$(b|+f%) ! Änderung abspeichern NEXT n% ! nächste Note innerhalb des Blocks ' ............................................................................ ' 5.) Geänderten Text darstellen und Blockmarken löschen: ' ............................................................................ SPUT g_lb$ ! Bild von Noten reinigen (Löschbild) @2_stueck_ganz_zeigen ! Geladenes Stück auf Bildschirm LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen ' ............................................................................ raus_bl_faehnchen: ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein PUT 0,0,g_kl$ ! Klaviatur von Infotext reinigen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 3_bl_transponieren !_: ' ---------------------------------------------------------------------------- ' Im 1. Teil wird die neue, gewünschte Starthöhe und die alte Starthöhe im ' Blockanfang festgestellt. Im 2. Teil werden die Ober- und Untergrenzen ' der Tonhöhen innerhalb des Blockbereichs ermittelt. Falls beim gewünschten ' Transponieren der Tonumfang des Programms gesprengt werden würde, wird ' im 3. Teil dann zum Prozedurende verzweigt. Im 4. Teil wird dann trans- ' poniert, im 5. Teil das Ergebnis dargestellt. ' ---------------------------------------------------------------------------- LOCAL a| ! Tonhöhe irgendeiner Note im Block LOCAL max_a| ! maximale Tonhöhe im Block LOCAL min_a| ! minimale Tonhöhe im Block LOCAL neu_sh| ! neue Starttonöhe LOCAL blk_sh| ! Starttonhöhe im Block LOCAL n% ! Notennrzähler für Blockschleife LOCAL diff| ! Transponierdiff. natürlich LOCAL diff% ! Transponierdiff. ganzzahlig LOCAL kl$ ! Klaviaturnegativ ' ............................................................................ GET 0,0,g_bb%-1,g_mh|-1,kl$ ! Klaviatur mit Hauptmenütext fotografieren PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"Neue Anfangsnote eingeben!" ! d PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor aus IF g_bla%=0 OR g_ble%=0 ! F Blockanfang oder - ende nicht gesetzt: GOTO raus_bl_transponieren ! raus ENDIF ! d ' ............................................................................ ' 0.) Auf neue Eingabe warten ' ............................................................................ REPEAT ! Warteschleife für Mausklick UNTIL MOUSEK ! Raus f Mausklick PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus LET x%=MOUSEX ! x-Koordinate festhalten IF MOUSEY>g_mh| ! F Maus auf Klaviatur GOTO raus_bl_transponieren ! d ENDIF ! d ' ............................................................................ ' 1.) Neue Starttonhöhe neu_h| für den Blockbereich feststellen ' ............................................................................ IF x%<g_ptb| OR x%>g_bb%-g_ptb| ! Pausentaste ? PRINT AT(1,1);"zu pausig!" ! Fehlermeldung PRINT CHR$(7); ! Gong ! PAUSE 40 ! Zeit zum Lesen GOTO raus_bl_transponieren ! d ELSE ! Notentaste: LET neu_sh|=TRUNC((x%-g_ptb|)/g_ntb|)+1! Neue Starttonhöe feststellen ENDIF ! d LET blk_sh|=ASC(LEFT$(g_n$(g_bla%),1))-64 ! Alte Starttonhöhe vom Blockanf. ' ............................................................................ ' 2.) Maximale & min. Tonhöhe (max_a| & min_a|) im Blockbereich feststellen: ' ............................................................................ LET min_a|=25 ! Minimum = höchstmögliche Notenhöhe FOR n%=g_bla% TO g_ble% ! den ganzen Block einschl. Grenzen durch: LET a|=ASC(LEFT$(g_n$(n%),1))-64! Tonhöhe der aktuellen Blocknote IF a|>max_a| AND NOT a|=26 ! F akt. Tonhöhe(=|=Pause) >maximale Tonhöhe LET max_a|=a| ! maximale Tonhöhe neu setzen ENDIF ! d IF a|<min_a| ! F akt. Tonhöhe < minimale Tonhöhe LET min_a|=a| ! minimale Tonhöhe neu setzen ENDIF ! d NEXT n% ! nächste Note innerhalb des Blocks ' ............................................................................ ' 3.) Raus, falls Transponierdifferenz für Tonumfang (c1-c3) zu groß: ' ............................................................................ IF neu_sh|<blk_sh| ! F nach unten transponiert werden soll: LET diff|=blk_sh|-neu_sh| ! Differenz der Starthöhen=Transponierdiff. IF min_a|-diff|<1 ! F minimale Tonhöhe unter c1 tr.würde PRINT AT(1,1);"zu tief!" ! Fehlermeldung PRINT CHR$(7); ! Gong ! PAUSE 40 ! Zeit zum Lesen GOTO raus_bl_transponieren ! d ENDIF ! d LET diff%=(-1)*diff| ! Zukünftige Transponierdiff. ganzzahlig ELSE IF neu_sh|>blk_sh| ! F nach oben transponiert werden soll LET diff|=neu_sh|-blk_sh| ! Differenz der Starthöhen=Transponierdiff. IF max_a|+diff|>25 ! F maximale Tonhöhe über c3 tr.würde PRINT AT(1,1);"zu hoch!" ! Fehlermeldung PRINT CHR$(7); ! Gong ! PAUSE 40 ! Zeit zum Lesen GOTO raus_bl_transponieren ! d ENDIF ! d LET diff%=diff| ! Zukünftige Transponierdiff. ganzzahlig ELSE ! sonst: PRINT AT(1,1);"zu gleich!" ! Fehlermeldung PRINT CHR$(7); ! Gong ! PAUSE 40 ! Zeit zum Lesen GOTO raus_bl_transponieren ! d ENDIF ! EFU nach oben / unten transponieren ' ............................................................................ ' 4.) Transponierschleife ' ............................................................................ FOR n%=g_bla% TO g_ble% ! den ganzen Block einschl. Grenzen durch: LET a|=ASC(LEFT$(g_n$(n%),1))-64! Tonhöhe der aktuellen Blocknote IF a|<>26 ! F Note keine Pause: MID$(g_n$(n%),1,1)=CHR$(a|+diff%+64) ! Änderung abspeichern ENDIF ! d NEXT n% ! nächste Note innerhalb des Blocks ' ............................................................................ ' 5.) Geänderten Text darstellen und Blockmarken löschen: ' ............................................................................ SPUT g_lb$ ! Bild von Noten reinigen (Löschbild) @2_stueck_ganz_zeigen ! Geladenes Stück auf Bildschirm LET g_bla%=0 ! Blockanfang löschen LET g_ble%=0 ! Blockende löschen LET g_n%=g_mn% ! Cursor auf letzte Note ' ............................................................................ raus_bl_transponieren: ! d PUT 0,0,kl$ ! Klaviatur mit Hauptmenütext raus PUT g_x%(g_n%),g_y%(g_n%),g_cs$,9 ! Cusor ein PUT 0,0,g_kl$ ! Klaviatur von Infotext reinigen ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 1_abspielgeschw !_: ' ---------------------------------------------------------------------------- LOCAL a ! Abspielgeschwindigkeitsfaktor LOCAL bld$ ! Bildschirmnegativ ' ............................................................................ SGET bld$ ! Bildschirm retten PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus nochmal_abspielgeschw: ! d PRINT AT(1,1);"bisher:";g_vz|/8;", 1=ganz schnell, 6=ganz langsam, neu: "; INPUT a ! Eingabe IF a<1 OR a>6 ! F Frequenz außerhalb erlaubtem Intervall: PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"zu extrem!" ! Fehlermeldung PRINT CHR$(7); ! Gong ! PAUSE 40 ! Zeit zum Lesen GOTO nochmal_abspielgeschw ! d ENDIF ! d LET g_vz|=8*a ! siehe auch '0_globalvariablen' SPUT bld$ ! Bildschirm wiederherstellen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_stueckpause !_: ' ---------------------------------------------------------------------------- LOCAL a1 ! Neue Frequenz für a1 LOCAL d ! Differenz neue und alte Frequenz von a1 LOCAL bld$ ! Bildschirmnegativ ' ............................................................................ SGET bld$ ! Bildschirm retten PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus nochmal_stueckpause: ! d PRINT AT(1,1);"bisher Stückpause: ";g_sp%;" /50-tel Sek., Neue Stückpause: "; INPUT a1 ! Eingabe IF a1<0 OR a1>100 ! F Pause außerhalb erlaubtem Intervall: PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"zu extrem!" ! Fehlermeldung PRINT CHR$(7); ! Gong ! PAUSE 40 ! Zeit zum Lesen GOTO nochmal_stueckpause ! d ENDIF ! d LET g_sp%=a1 ! Stückpause an Globalvariable übergeben SPUT bld$ ! Bildschirm wiederherstellen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_tonhoehe !_: ' ---------------------------------------------------------------------------- ' Funktionslos, seit 4 Oktaven möglich, siehe auch Prozedur 'a_2s' ' ---------------------------------------------------------------------------- LOCAL a1 ! Neue Frequenz für a1 LOCAL d ! Differenz neue und alte Frequenz von a1 LOCAL bld$ ! Bildschirmnegativ ' ............................................................................ SGET bld$ ! Bildschirm retten PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus nochmal_tonhoehe: ! d PRINT AT(1,1);"a1 hat bisher die Frequenz: ";fr%(10);", Neue Frequenz für a1: "; INPUT a1 ! Eingabe IF a1<100 OR a1>10000 ! F Frequenz außerhalb erlaubtem Intervall: PUT 0,0,g_kl$ ! Klaviatur ohne Hauptmenütext raus PRINT AT(1,1);"zu extrem!" ! Fehlermeldung PRINT CHR$(7); ! Gong ! PAUSE 40 ! Zeit zum Lesen GOTO nochmal_tonhoehe ! d ENDIF ! d SPUT bld$ ! Bildschirm wiederherstellen LET d=a1-fr%(10) ! Differenz: neue Frequenz/ alte Frequenz von a1 FOR i|=1 TO 50 ! Alle Frequenzdaten durch LET fr%(i|)=fr%(i|)+d ! neue Frequenzen berechnen NEXT i| ! nächste Note im Frequenzarray ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 1_midi_ein_aus !_: ' ---------------------------------------------------------------------------- IF g_midi!=FALSE ! F bisher aus: LET g_midi!=TRUE ! Midi ein ELSE ! sonst LET g_midi!=FALSE ! Midi aus ENDIF ! d ' ---------------------------------------------------------------------------- RETURN ' ------------------------------------------------------------------------------ > PROCEDURE 1_programmende(w|) !_: ' ---------------------------------------------------------------------------- LOCAL m| ! Menüwahlvariable ' w| ! Wahlvariable ' ............................................................................ IF w|=1 ! Edit gewählt: (Bei PD-Version draußen !) EDIT ! d ELSE IF w|=2 ! w|=2, Quit gewählt: @a_alert("Wirklich Interpreter verlassen?/Ja|Nein",m|) IF m|=1 ! F 'ja' gewählt: QUIT ! d ENDIF ! d ENDIF ! d ' ---------------------------------------------------------------------------- RETURN ' ############################################################################## ' A l e r t b o x p r o z e d u r e n : ' ############################################################################## > PROCEDURE a_alert(a1$,VAR w1|) t0t|=21 ' ---------------------------------------------------------------------------- ' Diese Prozedur entspricht einer Gem-Alertbox, es sind aber viel mehr ' Einträge möglich. ' Ein Alertübergabestring (Bsp.: "Hallo|Du ! Bist Du's ?/Ja|Nein") besteht ' aus einem Teil der nur angezeigt wird (der steht vor dem '/') und einem ' Teil, bei dem man aus den verschiedenen Einträgen auswählen kann (der ' steht hinter dem '/'). Beide Teile zusammen dürfen höchstens 20 Einträge ' haben, die höchstens 78 Zeichen breit sind ' ---------------------------------------------------------------------------- LOCAL i1% ! Zähler für Analyse des Menüeintragsstrings LOCAL i1| ! Zähler für Analyse des Menüeintragsstrings LOCAL j1| ! Zähler für Menüeintrage (erst nicht,dann whlb) LOCAL l1| ! Längenmaximum aller Einträge LOCAL mxb1| ! Maximum der nur anzuzeigenden Menüeinträge LOCAL mxw1| ! Maximum der wählbaren Menüeinträge LOCAL bld1$ ! Bildspeicher LOCAL sx1| ! Start-x-Spalte der Einträge LOCAL sy1| ! Start-y-Zeile der Einträge ' ............................................................................ FOR i1%=1 TO LEN(a1$) ! String durch IF MID$(a1$,i1%,1)="|" ! Grenze errcht INC j1| ! Zählr erhöh. ENDIF ! d IF MID$(a1$,i1%,1)="/" ! Grenze errcht LET mxb1|=j1|+1 ! Mx nur Bild CLR j1| ! Zähler null ENDIF ! d NEXT i1% ! nächst Buchst LET mxw1|=j1|+1 ! Mx wählbar ' ............................................................................ DIM b1$(mxb1|) ! Array für Menü mit nur angezeigten Eintägen DIM w1$(mxw1|) ! Array für Menü mit wählbaren Eintägen ' ............................................................................ ' Jetzt werden erst 'mal die Nurbildeinträge ausgefiltert LET j1|=1 ! Eintragszähler 1 FOR i1|=1 TO LEN(a1$) ! aString durch LET mi1$=MID$(a1$,i1|,1) ! akt. Zchn merken IF mi1$="|" OR mi1$="/" ! Eintragsgrenze errcht LET b1$(j1|)=LEFT$(a1$,i1|-1) ! Nurbildeintrag setzen IF l1|<LEN(b1$(j1|)) ! F neues Längenmaximum LET l1|=LEN(b1$(j1|)) ! übernehmen ENDIF ! d LET a1$=RIGHT$(a1$,LEN(a1$)-i1|) ! aString kürzen CLR i1| ! Zeichenzähler null INC j1| ! Eintragszählr erhöh. ENDIF ! d EXIT IF mi1$="/" ! Menügrenze errcht NEXT i1| ! nächst Buchst LET a1$=RIGHT$(a1$,LEN(a1$)-i1|) ! aString kürzen ' ............................................................................ ' Jetzt werden die Wahleinträge ausgefiltert LET j1|=1 ! Eintragszähler 1 REPEAT ! aString durch INC i1| ! nächste Zeichennummer LET mi1$=MID$(a1$,i1|,1) ! akt. Zchn merken IF mi1$="|" OR mi1$="/" ! Eintragsgrenze errcht LET w1$(j1|)=LEFT$(a1$,i1|-1) ! Wahleintrag setzen IF l1|<LEN(w1$(j1|)) ! F neues Längenmaximum LET l1|=LEN(w1$(j1|)) ! übernehmen ENDIF ! d LET a1$=RIGHT$(a1$,LEN(a1$)-i1|) ! aString kürzen CLR i1| ! Zeichenzähler null INC j1| ! Eintragszählr erhöh. ENDIF ! d UNTIL i1|=LEN(a1$) ! aString ganz durch LET w1$(j1|)=a1$ ! Wahleintrag setzen ' ............................................................................ IF b1$(1)<>"" ! d LET b1$(1)=LEFT$(b1$(1)+SPACE$(l1|),l1|)! Mit Spaces auffüllen ENDIF ! d IF w1$(1)<>"" ! d LET w1$(1)=LEFT$(w1$(1)+SPACE$(l1|),l1|)! Mit Spaces auffüllen ENDIF ! d ' ............................................................................ LET sx1|=ROUND((80-l1|)/2) ! Startspalte LET sy1|=ROUND((22-mxb1|)/2) ! Startzeile ' ............................................................................ ' Alertausschnitt (Kasten, der der Alertbox entspricht) ausschneiden, retten: GET (sx1|-1)*8-1,(sy1|-1)*16,sx1|*8+l1|*8,sy1|*16+(mxb1|+mxw1|)*16,bld1$ ' ............................................................................ @a_menue(-1,0,0,0,0,-1,sx1|,sy1|,1,mxb1|,dummy1|,dummy1|,b1$(),d!()) REPEAT ! Solange neues Menü, @a_menue(-1,-1,-1,0,0,-1,sx1|,sy1|+mxb1|,1,mxw1|,dummy1|,w1|,w1$(),d!()) UNTIL w1|<>0 ! bis Eintrag gewählt ' ............................................................................ PUT (sx1|-1)*8-1,(sy1|-1)*16,bld1$ ! Alertausschnitt zurück ' ............................................................................ ERASE b1$() ! Array für Menü mit nur angezeigten Eintägen ERASE w1$() ! Array für Menü mit wählbaren Eintägen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_menue(ad!,wv!,we1!,wex!,inp!,rmn!,sx|,sy|,sp|,zl|,VAR m|,w|,a$(),a!()) t0t|=22 ' ---------------------------------------------------------------------------- ' Mit dieser Prozedur kann man ein Menü erzeugen. Dessen Einträge müssen ' sich im Übergabearray a$() befinden. Welcher Eintrag gewählt wurde, ' erfährt man nach Prozedurende im Rückgabeparametzer w|. Es gibt ' einige Zusätzliche Einstellungen, die im folgenden aufgelistet sind: ' ---------------------------------------------------------------------------- ' ' Übergabevariablen: ' ' ad! = Auch Darstellung des Menüs ? nein=0, ja=-1 ' wv! = Wahlvorschlag (1.Eintrag) ein (-1) oder aus (0) ' we1! = wählbare Einträge(nur 1) (-1) oder nicht (0: also Menü nur abbilden) ' wex! = alle (insbes. mehr als ein Eintrag) Einträge wählbar ? ja=-1, nein=0 ' inp! = Input (-1:schließt bis jetzt wex!=-1 aus!) oder nicht (0) ' rmn! = Rahmen (-1) oder nicht (0) ' sx| = Start-x-Koordinate (in Zeichen) von Menüeinträgen links ' sy| = Start-y-Koordinate (in Zeichen) von Menüeinträgen oben ' sp| = Spaltenanzahl der Menüeinträge ' zl| = Zeilenanzahl der Menüeinträge ' m| = Maustastennummer 0=linke, 1=rechte Maustaste ' w| = Wahlnummer des gewählten Eintrages auch zurück ! ' a$() = Eintragsarray, hier sind alle Einträge drin auch zurück ! ' a!() = Wahlarray hier steht an erster Stelle eine 0, falls der entsprechende ' Eintrag in a$() nicht gewählt und -1, falls er gewählt. ' ' ............................................................................ LOCAL di| ! Die Anzahl der Spaces, die wegen der Inputfunktion ' ! jedem Eintrag hinten drangefügt werden (in letzter ' ! Procedure wieder abgezogen) LOCAL ml| ! Eintragslängenmaximum ' ............................................................................ REPEAT ! Warteschleife für Mauseingabe: UNTIL MOUSEK=0 ! Erst Raus,wenn Maus nix mehr meldet,also Puffer leer ' ............................................................................ @a_menueeintraege_maximieren(sp|,zl|,ml|,di|,a$()) ! d IF rmn!=-1 ! Mit Rahmen @a_menuerahmen(ml|,sx|,sy|,sp|,zl|) ! d ENDIF ! d IF we1!=0 AND ad! ! Menü nur anzgen @a_menue_anzeigen(ml|,sx|,sy|,sp|,zl|,a$()) ! d ELSE IF inp!=0 ! Wählen oh.Input IF ad! ! f auch darstellen @a_menue_anzeigen(ml|,sx|,sy|,sp|,zl|,a$()) ! d ENDIF ! d IF wex! ! F alle Einträge wählb. @a_eintraege_waehlen(wv!,ml|,sx|,sy|,sp|,zl|,a$(),a!(),m|,w|) ! d ELSE ! F nur 1 Eintrag wählb. @a_eintrag_waehlen(wv!,ml|,sx|,sy|,sp|,zl|,a$(),m|,w|) ! d ENDIF ! d ELSE ! Wähln mit Input IF ad! ! f auch darstellen @a_menue_anzeigen(ml|,sx|,sy|,sp|,zl|,a$()) ! d ENDIF ! d @a_eintrag_waehlen(wv!,ml|,sx|,sy|,sp|,zl|,a$(),m|,w|) ! d IF w|<>0 ! F Eintrag gew. @a_eintraginput(ml|,di|,sx|,sy|,sp|,zl|,m|,w|,a$()) ! d IF a$(w|)=" " ! F nix eingeg. LET w|=0 ! Abbruchcode ENDIF ! d ENDIF ! d ENDIF ! d @a_menueeintraege_minus_di8(sp|,zl|,ml|,di|,a$()) ! Inputzusatz wiederweg ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_menueeintraege_maximieren(sp3|,zl3|,VAR ml3|,di3|,a3$()) t2t|=23 ' ---------------------------------------------------------------------------- ' Hier werden alle Einträge mit Spaces aufgefüllt, bis sie alle gleich ' lang sind. ' ---------------------------------------------------------------------------- ' di3| ! Zusätzliche Spaces am Ende jedes ' ! Eintrages, um nachher korrektes ' ! Input zu ermöglichen ' ! Diese Variable ist Rückgabeparameter ' ml3| ! Eintragslängenmaximum ist " ' ............................................................................ LOCAL i3| ! Zähler für Einträge ' ............................................................................ LET di3|=1 ! Für Input zusätliche di3| Spaces LET ml3|=0 ! Eintragslängenmaximum null setzen ' ............................................................................ FOR i3|=1 TO sp3|*zl3| ! Alle Einträge durch IF LEN(a3$(i3|))>ml3| ! Falls Eintrag größer als bisher LET ml3|=LEN(a3$(i3|)) ! Maximum Eintraglänge neu setzen ENDIF ! d NEXT i3| ! nächster Eintrag ' ............................................................................ FOR i3|=1 TO sp3|*zl3| !Alledurch a3$(i3|)=LEFT$(a3$(i3|)+SPACE$(ml3|),ml3|)!Auffüllen a3$(i3|)=a3$(i3|)+SPACE$(di3|) !für Input NEXT i3| ! nächster ' ............................................................................ ADD ml3|,di3| ! Eintragslänge anpassen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_menuerahmen(ml4|,sx4|,sy4|,sp4|,zl4|) t2t|=24 ' ---------------------------------------------------------------------------- ' In dieser Prozedur erhält das kommende Menü einen Rahmen. ' ---------------------------------------------------------------------------- LOCAL dx4| ! Distanz zwischen Rahmen und Eintragsrand in x-Richtung LOCAL dy4| ! Distanz zwischen Rahmen und Eintragsrand in y-Richtung LOCAL lx4% ! Position des Rahmens links LOCAL oy4% ! Position des Rahmens oben LOCAL rx4% ! Position des Rahmens rechts LOCAL uy4% ! Position des Rahmens unten ' ............................................................................ LET dx4|=1 ! Randabstand x LET dy4|=1 ! Randabstand y LET lx4%=(sx4|-1)*8-dx4| ! Links LET oy4%=sy4|*16-dy4| ! Oben LET rx4%=lx4%+ml4|*sp4|*8+dx4| ! Rechts LET uy4%=oy4%+zl4|*16+dy4| ! Unten ' ............................................................................ BOX lx4%,oy4%,rx4%,uy4% ! Rahmen Zeichnen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_menue_anzeigen(ml5|,sx5|,sy5|,sp5|,zl5|,VAR a5$()) t2t|=25 ' ---------------------------------------------------------------------------- ' In dieser Prozedur wird das Menü erst einmal nur angezeigt. Wählen kann ' man hier also noch nicht. ' ---------------------------------------------------------------------------- LOCAL i5| ! Spaltenzähler für Eintragsspalten LOCAL j5| ! Zeilenzähler für Eintragsszeilen LOCAL k5| ! Eintragszähler ' ............................................................................ FOR i5|=1 TO sp5| ! Alle Spalten durch FOR j5|=1 TO zl5| ! Alle Zeilen durch INC k5| ! Nächster Eintrag; Ausgeben: PRINT AT(sx5|+(i5|-1)*ml5|,sy5|+j5|);a5$(k5|) NEXT j5| ! Nächste Zeile NEXT i5| ! Nächste Spalte ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_eintrag_waehlen(wv!,ml|,sx|,sy|,sp|,zl|,VAR a$(),m|,w|) t2t|=26 ' ---------------------------------------------------------------------------- ' Diese Prozedur sorgt dafür, daß der Menüeintrag, auf den die Maus gerade ' zeigt, invers dargestellt wird. Dabei wird natürlich der letzte Eintrag ' wieder normal dargestellt. Falls der erste Übergabeparameter wv! ' wahr ist, so wird der erste Eintrag beim Aufruf der Prozedur automatisch ' invers dargestellt, so daß die Maus gar nicht mehr gebraucht wird. Ein ' Druck auf die [Return]-Taste reicht, um den vorgeschlagenen Eintrag als ' gewählt zu betrachten und die Prozedur zu verlassen. Statt der [Return]- ' Taste kann man auch die linke Maustaste zum entültigen wählen benutzen. ' ---------------------------------------------------------------------------- LOCAL mef! ! Maus nicht auf Menüeintrag ? LOCAL erst! ! Erster Durchgang ? LOCAL bs! ! Bildschirm schwarz gewesen ? LOCAL i| ! Hier steht die Eintragsnummer LOCAL t% ! Zeitmesser für Bildschirmabschaltung LOCAL x% ! Maus-x-Koordinate LOCAL y% ! Maus-y-Koordinate LOCAL sm% ! Die Spalte, auf die die Maus gerade zeigt LOCAL zm% ! Die Zeile, auf die die Maus gerade zeigt LOCAL ms% ! Speicher für sm% LOCAL mz% ! Speicher für mz% LOCAL st% ! Spaltenterm LOCAL zt% ! Zeilenterm LOCAL mx% ! Speicher für x-Koordinate LOCAL my% ! Speicher für y-Koordinate LOCAL b$ ! Negativspeicher für Bildschirmrettung ' ............................................................................ LET erst!=TRUE ! Erster Durchgang ' ............................................................................ REPEAT ! Mausabfrageschleife ' .......................................................................... LET mef!=FALSE ! Maus ist erst mal evtl. auf Menüeintrag ' .......................................................................... IF NOT bs! ! F Bildschirm nicht schwarz: SHOWM ! Mauszeiger bitte an und zwar immer !!! ENDIF ! d ' .......................................................................... LET x%=MOUSEX ! Maus-x-Koordinate LET y%=MOUSEY ! Maus-y-Koordinate ' .......................................................................... ' ! S c h w a r z s c h a l t u n g : INC t% ! Zeitmesser raufsetzen IF t%=20000 ! F Zeit für Bildschirmabschaltung: HIDEM ! Maus weg IF bs!=FALSE ! F Bildschirm bisher noch nicht schwarz SGET b$ ! Bildschirm retten ENDIF ! d PBOX 0,0,g_bb%-1,g_bh%-1 ! Bildschirm schwarz LET bs!=TRUE ! Bildschirm schwarz merken LET t%=0 ! Weiterlaufen ohne Overflow, deshalb null setzen ENDIF ! d IF (mx%<>x% OR my%<>y%) AND bs!=TRUE! F Mausbewegung + Blds.schwarz LET t%=0 ! Weiterlaufen ohne Overflow LET bs!=FALSE ! Bildschirm nicht mehr schwarz SPUT b$ ! Bildschirm wieder herstellen SHOWM ! Maus her ENDIF ! d LET mx%=MOUSEX ! X-Koordinate der Maus merken LET my%=MOUSEY ! Y-Koordinate der Maus merken ' .......................................................................... LET st%=x%-sx|*8 ! Spaltenterm LET zt%=y%-sy|*16 ! Zeilenterm ' Aktuelle Spalte (sm%) und Zeile (zm%) ermitteln: LET sm%=TRUNC((st%)/(ml|*8))+1 ! Akt.Spalte LET zm%=TRUNC((zt%)/16)+1 ! Akt.Zeile ' .......................................................................... ' Beides negativ, f Maus 1 Sp. links oder 1 Zl. oberhalb des Menüs: IF st%<0 ! nicht /0 LET sm%=0 ! Simuliere Sp 0 LET zm%=0 ! Simuliere Z 0 LET mef!=TRUE ! M. n. auf Menü ENDIF ! d IF zt%<0 ! nicht /0 LET sm%=0 ! Simuliere Sp 0 LET zm%=0 ! Simuliere Z 0 LET mef!=TRUE ! M. n. auf Menü ENDIF ! d ' .......................................................................... IF sm%>sp| ! Falls Maus rechts der letzten Spalte LET sm%=0 ! Simuliere Spalte 0 LET zm%=0 ! Simuliere Zeile 0 LET mef!=TRUE ! Maus ist nicht auf Menüeintrag ENDIF ! d IF zm%>zl| ! Falls Maus unterhalb der letzten Zeile LET sm%=0 ! Simuliere Spalte 0 LET zm%=0 ! Simuliere Zeile 0 LET mef!=TRUE ! Maus ist nicht auf Menüeintrag ENDIF ! d ' .......................................................................... ' PRINT AT(1,15);sm%,zm%,mef! IF erst!=TRUE ! F das 1. Mal hier LET erst!=FALSE ! Durchgangsnummer > 0 IF wv!=TRUE ! Menüvorschlag: ja LET sm%=1 ! Simuliere Spalte 1 LET zm%=1 ! Simuliere Zeile 1 LET ms%=sm% ! jetzige Spalte merken LET mz%=zm% ! jetzige Zeile merken PRINT CHR$(27);CHR$(112); ! Invers ein LET i|=1 ! erste Eintragsnummer ' LET i|=(sm%-1)*zl|+zm% ! alte Eintragsnummer PRINT AT(sx|+(sm%-1)*ml|,sy|+zm%);a$(i|) PRINT CHR$(27);CHR$(113); ! Invers aus ENDIF ! d ELSE ! Falls mind. 1mal durch IF mef!=FALSE ! Maus ist auf Menüeintrag IF sm%<>ms% OR zm%<>mz% ! Falls Sp.od.Zle geänd. IF ms%<>0 AND mz%<>0 ! Letzter Eintr. vorhanden PRINT CHR$(27);CHR$(113); ! Invers aus LET i|=(ms%-1)*zl|+mz%! alte Eintragsnummer PRINT AT(sx|+(ms%-1)*ml|,sy|+mz%);a$(i|) ENDIF ! d PRINT CHR$(27);CHR$(112); ! Invers ein LET i|=(sm%-1)*zl|+zm% ! neue Eintragsnummer PRINT AT(sx|+(sm%-1)*ml|,sy|+zm%);a$(i|) PRINT CHR$(27);CHR$(113); ! Invers aus LET ms%=sm% ! jetzige Spalte merken LET mz%=zm% ! jetzige Zeile merken ENDIF ! EF Sp. oder Zl. geändert ENDIF ! d ENDIF ! d ' .......................................................................... LET m|=MOUSEK ! Maustaste retten EXIT IF mef!=TRUE AND m| ! Raus f MT neben Menüfeld ' .......................................................................... UNTIL mef!=FALSE AND m| AND mz%<>0 ! Raus,f RMT auf Menüfeld ' ............................................................................ IF mef!=TRUE ! F nicht auf Menüfeld ' .......................................................................... LET w|=0 ! Kein Eintrag gewählt ' .......................................................................... ELSE ! F auf Menüfeld ' .......................................................................... ' Gewählten Eintrag wieder normal darstellen: PRINT CHR$(27);CHR$(113); ! Invers aus LET i|=(ms%-1)*zl|+mz% ! alte Eintragsnummer PRINT AT(sx|+(ms%-1)*ml|,sy|+mz%);a$(i|) ! normale Ausgabe ' .......................................................................... LET w|=i| ! In den Rückgabepar.die Nr.d.gewählten Eintrags ' .......................................................................... ENDIF ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_eintraege_waehlen(wv!,ml|,sx|,sy|,sp|,zl|,VAR a$(),a!(),m|,w|) t2t|=26 ' ---------------------------------------------------------------------------- ' Diese Prozedur sorgt dafür, daß der Menüeintrag, auf den die Maus gerade ' zeigt, invers dargestellt wird. Dabei wird natürlich der letzte Eintrag ' wieder normal dargestellt. Falls der erste Übergabeparameter wv! ' wahr ist, so wird der erste Eintrag beim Aufruf der Prozedur automatisch ' invers dargestellt, so daß die Maus gar nicht mehr gebraucht wird. Ein ' Druck auf die [Return]-Taste reicht, um den vorgeschlagenen Eintrag als ' gewählt zu betrachten und die Prozedur zu verlassen. Statt der [Return]- ' Taste kann man auch die linke Maustaste zum entültigen Wählen benutzen. ' (Die 'Return'-Taste funktioniert jetzt nicht mehr!) ' ---------------------------------------------------------------------------- LOCAL mef! ! Maus nicht auf Menüeintrag ? LOCAL erst! ! Erster Durchgang ? LOCAL i| ! Hier steht die Eintragsnummer LOCAL x% ! Maus-x-Koordinate LOCAL y% ! Maus-y-Koordinate LOCAL sm% ! Die Spalte, auf die die Maus gerade zeigt LOCAL zm% ! Die Zeile, auf die die Maus gerade zeigt LOCAL ms% ! Speicher für sm% LOCAL mz% ! Speicher für mz% LOCAL st% ! Spaltenterm LOCAL zt% ! Zeilenterm ' ............................................................................ LET erst!=TRUE ! Erster Durchgang ' ............................................................................ grosse_eingabeschleife: ! Anfang der Hauptschleife ' ............................................................................ REPEAT ! Mausabfrageschleife ' .......................................................................... LET mef!=FALSE ! Maus ist erst mal evtl. auf Menüeintrag ' .......................................................................... SHOWM ! Mauszeiger bitte an und zwar immer !!! ' .......................................................................... LET x%=MOUSEX ! Maus-x-Koordinate LET y%=MOUSEY ! Maus-y-Koordinate ' .......................................................................... LET st%=x%-sx|*8 ! Spaltenterm LET zt%=y%-sy|*16 ! Zeilenterm ' Aktuelle Spalte (sm%) und Zeile (zm%) ermitteln: LET sm%=TRUNC((st%)/(ml|*8))+1 ! Akt.Spalte LET zm%=TRUNC((zt%)/16)+1 ! Akt.Zeile ' .......................................................................... ' Beides negativ, f Maus 1 Sp. links oder 1 Zl. oberhalb des Menüs: IF st%<0 ! nicht /0 LET sm%=0 ! Simuliere Sp 0 LET zm%=0 ! Simuliere Z 0 LET mef!=TRUE ! M. n. auf Menü ENDIF ! d IF zt%<0 ! nicht /0 LET sm%=0 ! Simuliere Sp 0 LET zm%=0 ! Simuliere Z 0 LET mef!=TRUE ! M. n. auf Menü ENDIF ! d ' .......................................................................... IF sm%>sp| ! Falls Maus rechts der letzten Spalte LET sm%=0 ! Simuliere Spalte 0 LET zm%=0 ! Simuliere Zeile 0 LET mef!=TRUE ! Maus ist nicht auf Menüeintrag ENDIF ! d IF zm%>zl| ! Falls Maus unterhalb der letzten Zeile LET sm%=0 ! Simuliere Spalte 0 LET zm%=0 ! Simuliere Zeile 0 LET mef!=TRUE ! Maus ist nicht auf Menüeintrag ENDIF ! d ' .......................................................................... ' PRINT AT(1,15);sm%,zm%,mef! IF erst!=TRUE ! F das 1. Mal hier LET erst!=FALSE ! Durchgangsnummer > 0 IF wv!=TRUE ! Menüvorschlag: ja LET sm%=1 ! Simuliere Spalte 1 LET zm%=1 ! Simuliere Zeile 1 LET ms%=sm% ! jetzige Spalte merken LET mz%=zm% ! jetzige Zeile merken PRINT CHR$(27);CHR$(112); ! Invers ein LET i|=1 ! erste Eintragsnummer ' LET i|=(sm%-1)*zl|+zm% ! alte Eintragsnummer PRINT AT(sx|+(sm%-1)*ml|,sy|+zm%);a$(i|) ! Eintrag ausgeben PRINT CHR$(27);CHR$(113); ! Invers aus ENDIF ! d ELSE ! Falls mind. 1mal durch IF mef!=FALSE ! Maus ist auf Menüeintrag IF sm%<>ms% OR zm%<>mz% ! Falls Sp.od.Zle geänd. IF ms%<>0 AND mz%<>0 ! Letzter Eintr. vorhanden PRINT CHR$(27);CHR$(113); ! Invers aus LET i|=(ms%-1)*zl|+mz% ! alte Eintragsnummer IF a!(i|)=FALSE ! F nicht gewählt: PRINT AT(sx|+(ms%-1)*ml|,sy|+mz%);a$(i|) ! Eintrag ausgeben ENDIF ! d ENDIF ! d PRINT CHR$(27);CHR$(112); ! Invers ein LET i|=(sm%-1)*zl|+zm% ! neue Eintragsnummer PRINT AT(sx|+(sm%-1)*ml|,sy|+zm%);a$(i|) PRINT CHR$(27);CHR$(113); ! Invers aus LET ms%=sm% ! jetzige Spalte merken LET mz%=zm% ! jetzige Zeile merken ENDIF ! EF Sp. oder Zl. geändert ENDIF ! d ENDIF ! d ' .......................................................................... LET m|=MOUSEK ! Maustaste retten IF m|=2 ! F rechte Maustaste: LET mef!=TRUE ! Auch raus ENDIF ! d EXIT IF mef!=TRUE AND m| ! Raus f MT neben Menüfeld ' .......................................................................... UNTIL mef!=FALSE AND m| AND mz%<>0 ! Raus,f RMT auf Menüfeld ' ............................................................................ IF mef!=FALSE ! F auf Menüfeld ' .......................................................................... ' Gewählten Eintrag merken, d.h. in a!() als gewählt/nicht gew. verzeichnen: ' .......................................................................... LET i|=(ms%-1)*zl|+mz% ! alte Eintragsnummer ' .......................................................................... IF a!(i|)=TRUE ! F bereits gewählt: LET a!(i|)=FALSE ! Code für 'Eintrag nicht gew.' PRINT CHR$(27);CHR$(113); ! Invers aus PRINT AT(sx|+(ms%-1)*ml|,sy|+mz%);a$(i|) ! Eintrag ausgeben ELSE ! F noch nicht gewählt: LET a!(i|)=TRUE ! Code für 'Eintrag gewählt' PRINT CHR$(27);CHR$(112); ! Invers ein PRINT AT(sx|+(ms%-1)*ml|,sy|+mz%);a$(i|) ! Eintrag ausgeben LET w|=1 ! etwas gewählt ENDIF ! EFU bereits gewählt/nicht gew ' .......................................................................... REPEAT ! Warteschleife für Mauseingabe: UNTIL MOUSEK=0 ! Erst Raus,wenn Maus nix mehr meldet,also Puffer leer ' .......................................................................... GOTO grosse_eingabeschleife ! geh zum Anfang der Hauptschl. ' .......................................................................... ENDIF ! d PRINT CHR$(27);CHR$(113); ! Invers aus ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_eintraginput(ml7|,di7|,sx7|,sy7|,sp7|,zl7|,m7|,w7|,VAR a7$()) t2t|=27 ' ---------------------------------------------------------------------------- ' Hier kann man in einem Menüeintrag etwas eingeben. ' ---------------------------------------------------------------------------- LOCAL si7| ! Spalte für Input LOCAL zi7| ! Zeile für Input ' ............................................................................ ' si7|=TRUNC(w7|/sp7|)+1 ! Spalte f.Input ' PRINT AT(1,1);"w7|,sp7|,si7|,zl7|" ! Zeile f. Input ' PRINT AT(1,2);w7|,sp7|,si7|,zl7| ! Zeile f. Input ' zi7|=w7|-(si7|-1)*zl7| ! Zeile f. Input ' .......................................................................... LET x7%=MOUSEX ! Maus-x-Koordinate LET y7%=MOUSEY ! Maus-y-Koordinate LET st7%=x7%-sx7|*8 ! Spaltenterm LET zt7%=y7%-sy7|*16 ! Zeilenterm ' Aktuelle Spalte (sm7%) und Zeile (zm7%) ermitteln: LET sm7%=TRUNC((st7%)/(ml7|*8))+1 ! Akt.Spalte LET zm7%=TRUNC((zt7%)/16)+1 ! Akt.Zeile LET si7|=sm7% ! Var-Type ändern LET zi7|=zm7% ! Var-Type ändern ' ............................................................................ ' PRINT AT(sx7|+(si7|-1)*ml7|-1,sy7|+zi7|); ! Positionieren ' ............................................................................ LET a$=a7$(w7|) ! Zwischenspeicher @a_input(sx7|+(si7|-1)*ml7|,sy7|+zi7|,ml7|-1,m7|,a$)! Eingabe LET a7$(w7|)=a$ ! Rückgabe ' FORM INPUT ml7|-1 AS a7$(w7|) ! Eingabe ' ............................................................................ ' Alle Strings wurden, um das Input überhaupt zu ermöglichen, um di7| ' Spaces am rechten Rand erweitert, das muß auch mit dem geängerten ' String geschehen. Das passiert in der folgenden Zeile: LET a7$(w7|)=a7$(w7|)+SPACE$(di7|) ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_input(sp|,zl|,l|,m|,VAR a$) ' ---------------------------------------------------------------------------- ' sp| ! Startspalte der Eingabe ' zl| ! Startzeile der Eingabe ' l| ! Sollänge der Eingabe ' a$ ! Eingabestring,evtl. ist Vorschlag drin LOCAL z| ! Ascii-Speicher für eingegebenes Zeichn LOCAL al| ! Aktuelle Länge des Eingabestrings ' ............................................................................ LET a$=LEFT$(a$,l|) ! Überflüssiges am Vorschlagstring weg. ' ............................................................................ PRINT AT(sp|,zl|);a$;CHR$(27);CHR$(112);" ";CHR$(27);CHR$(113); ! Cursor ein ' ............................................................................ HIDEM ! Mauspfeil weg REPEAT ! Warteschleife für Mauseingabe: UNTIL MOUSEK=0 ! Erst Raus,wenn Maus nix mehr meldet,also Puffer leer ' ............................................................................ DO ! Hauptschleifenanfang ' .......................................................................... REPEAT ! Eingabeschleife LET z|=ASC(INKEY$) ! Zeichen von der Tastatur lesen LET m|=MOUSEK ! Maustaste retten IF MOUSEK ! F Maustaste gedrückt LET z|=13 ! Tu so, als sei 'Return'-Taste gedrückt ENDIF ! d UNTIL z|=8 OR z|=13 OR z|>31 ! Raus f Zeichen eingegeben LET al|=LEN(a$) ! Aktuelle Länge abspeichern EXIT IF z|=13 ! Raus f 'RETURN'-Taste gedrückt ' .......................................................................... IF z|=8 AND al|>0 ! F 'BACKSPACE'-Taste und String<>leer LET a$=LEFT$(a$,al|-1) ! Backspace ausführen DEC al| ! Aktuelle Stringlänge aktualisieren PRINT AT(sp|,zl|);a$;CHR$(27);CHR$(112);" ";CHR$(27);CHR$(113);! Zchn raus IF al|<l| ! F akt. Länge < Sollänge PRINT SPACE$(l|-al|) ! rechts Vom Cursor weiß ENDIF ! d ELSE IF al|<l| AND z|>31 ! F Normale Taste und kleiner Maxlänge LET a$=a$+CHR$(z|) ! Eingabestring erweitern LET a$=UPPER$(a$) ! Nur Großbuchstaben INC al| ! Aktuelle Stringlänge aktualisieren PRINT AT(sp|,zl|);a$;CHR$(27);CHR$(112);" ";CHR$(27);CHR$(113);! Zchn raus IF al|<l| ! F akt. Länge < Sollänge PRINT SPACE$(l|-al|) ! rechts Vom Cursor weiß ENDIF ! d ENDIF ! d ' .......................................................................... LOOP ! Hauptlschleifenende ' ............................................................................ LET a$=a$+SPACE$(l|-al|) ! Rechts mit Spaces auffüllen ' ---------------------------------------------------------------------------- RETURN > PROCEDURE a_menueeintraege_minus_di8(sp8|,zl8|,ml8|,di8|,VAR a8$()) ' ---------------------------------------------------------------------------- ' Hier wird die zusätzliche Länge für Input wieder abgezogen ' ---------------------------------------------------------------------------- LOCAL i8| ! Zähler für Einträge ' ............................................................................ LET di8|=1 ! Für Input zusätliche di8| Spaces ' ............................................................................ FOR i8|=1 TO sp8|*zl8| ! Alle Einträge durch LET a8$(i8|)=LEFT$(a8$(i8|),ml8|-di8|) ! Inputlängenzugabe wieder abziehen NEXT i8| ! nächster Eintrag ' ---------------------------------------------------------------------------- RETURN ' ############################################################################## ' D a t e n ' ############################################################################## > PROCEDURE 0_menuedaten ' ---------------------------------------------------------------------------- hauptmenue: DATA Stückmenü DATA Hauptfile DATA Blockmenü DATA Parameter DATA Menü-Exit DATA ## ' ............................................................................ stueckmenue: DATA Stück auf Disk speichern DATA Stück von Disk laden DATA ---------------------------- DATA Stück in Hauptfile speichern DATA Stück von Hauptfile laden DATA ---------------------------- DATA bestimmte Stücke drucken DATA bestimmte Stücke spielen DATA ## ' ............................................................................ hauptfile: DATA Hauptfile neuanlegen DATA Hauptfile neu laden DATA Hauptfile abspeichern DATA ---------------------------- DATA beliebiges Diskfile löschen DATA Diskfile umbenennen DATA ---------------------------- DATA Inhaltsverzeichnis drucken DATA Ab x alle Stücke drucken DATA Ab x alle Stücke spielen DATA ## ' ............................................................................ blockmenue: DATA Anfang DATA Ende DATA Marken löschen DATA ------------------ DATA kopieren DATA doppelt so schnell DATA halb so schnell DATA transponieren DATA ------------------ DATA löschen DATA ## ' ............................................................................ parameter: DATA Abspielgeschwindigkeit DATA Pause zw. den Stücken DATA Midi ein/aus schalten DATA ## ' ............................................................................ menue_exit: DATA Eingabe fortsetzen DATA ------------------ DATA Edit DATA ------------------ DATA Quit DATA ## ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_tonleiterdaten tonleiter: DATA C,#C,D,#D,E,F,#F,G,#G,A,#A,H,PP RETURN > PROCEDURE 0_hilfstext_mit_befehlstabelle ' ---------------------------------------------------------------------------- ' Hier befindet sich bisher nur der Hilfstext, den man über die Help-Taste ' erreichen kann. ' ---------------------------------------------------------------------------- ' helptext: ' DATA Prg zum Schreiben von Flötenstücken 'NOTEDITA.GFA' 1.0 | DATA DATA DATA DATA DATA DATA DATA DATA DATA DATA ################################################################################ DATA | linksoben | Notentaste | rechtsoben | Notentext | Cursor | DATA DATA |--------------------------------------------------------------| DATA LMT | Pause | 1/8 Note | Pause | Cursorpos. | Taktstr. | DATA |------------+------------+------------+------------+----------| DATA RMT | Hauptmenü | Nur Ton | Backspace | Abspielen | Fähnchen | DATA |--------------------------------------------------------------| DATA ################################################################################ DATA 'LMT'=linke Maustaste / 'RMT'=rechte Maustaste / 'Taktstr.'=Taktstrich DATA ################################################################################ DATA ############ !!!! Der Verkauf des Programms ist nicht erlaubt !!!! ############ DATA ############ Das Programm darf nur unverändert weitergegeben werden ############ DATA ################################################################################ DATA Zurück zum Editor: Maustaste / Autor: M.Mittelmaier Sommer '89 DATA ** ' ' ' ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_frequenzdaten frequenzen: ' ---------------------------------------------------------------------------- ' Erst die Halbtonfrequenzen: ' ---------------------------------------------------------------------------- ' c1 DATA 262 ' cis1 DATA 275 ' d1 DATA 294 ' dis1 DATA 312 ' e1 DATA 330 ' f1 DATA 350 ' fis1 DATA 371 ' g1 DATA 393 ' gis1 DATA 415 ' a1 DATA 440 ' ais1 DATA 466 ' h1 DATA 495 ' c2 DATA 526 ' cis2 DATA 558 ' d2 DATA 591 ' dis2 DATA 625 ' e2 DATA 662 ' f2 DATA 701 ' fis2 DATA 744 ' g2 DATA 787 ' gis2 DATA 838 ' a2 DATA 880 ' ais2 DATA 933 ' h2 DATA 990 ' c3 DATA 1050 ' ---------------------------------------------------------------------------- ' Nun die Vierteltonfrequenzen: ' ---------------------------------------------------------------------------- ' c1 + Viertelton DATA 268 ' cis1 + Viertelton DATA 282 ' d1 + Viertelton DATA 303 ' dis1 + Viertelton DATA 321 ' e1 + Viertelton DATA 340 ' f1 + Viertelton DATA 360 ' fis1 + Viertelton DATA 382 ' g1 + Viertelton DATA 404 ' gis1 + Viertelton DATA 427 ' a1 + Viertelton DATA 453 ' ais1 + Viertelton DATA 480 ' h1 + Viertelton DATA 510 ' c2 + Viertelton DATA 542 ' cis2 + Viertelton DATA 574 ' d2 + Viertelton DATA 608 ' dis2 + Viertelton DATA 643 ' e2 + Viertelton DATA 681 ' f2 + Viertelton DATA 722 ' fis2 + Viertelton DATA 765 ' g2 + Viertelton DATA 809 ' gis2 + Viertelton DATA 856 ' a2 + Viertelton DATA 906 ' ais2 + Viertelton DATA 961 ' h2 + Viertelton DATA 1020 ' c3 + Viertelton DATA 1082 ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_daten_fuer_notenschluessel ' ---------------------------------------------------------------------------- notenschluessel: DATA 170,169,170,168,167,168,167,169,168,171 DATA 173,172,173,170,173,167,170,166,169,165 DATA 167,165,166,165,164,170,165,173,169,175 DATA 173,175,176,173,177,169,177,166,168,133 DATA 167,120,172,116,176,115,176,115,178,117 DATA 180,118,181,122,181,126,180,130,179,133 DATA 165,146,164,151,164,158,169,160,176,161 DATA 180,159,180,153,178,149,173,148,168,148 DATA 167,149,167,154,172,157,174,157,178,157 DATA -1,-1 ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_daten_fuer_programmname ' ---------------------------------------------------------------------------- programmname: DATA 451,13,452,9,457,4,464,4,467,8 DATA 467,13,477,3,467,13,478,13,488,7 DATA 481,11,485,13,498,13,499,8,490,4 DATA 487,6,489,7,487,9,497,8,504,11 DATA 517,4,518,12,518,14,515,8,515,8 DATA 518,9,521,10,525,10,518,10,513,9 DATA 513,9,511,9,519,14,526,15,537,13 DATA 540,7,534,6,532,9,541,14,547,14 DATA 559,9,552,10,552,12,556,14,562,15 DATA 565,11,559,8,564,10,568,3,565,14 DATA 565,14,571,13,578,9,579,6,577,4 DATA 577,4,579,4,580,4,581,4,583,5 DATA 584,5,580,5,579,5,579,5,579,8 DATA 579,9,579,11,582,13,586,13,595,12 DATA 599,6,601,3,601,7,601,13,601,13 DATA 601,13,602,11,602,8,599,7,596,9 DATA 596,9,599,8,603,8,606,7,597,6 DATA 595,6,601,12,603,14,609,13,617,8 DATA 622,6,629,6,620,6,616,10,616,11 DATA 621,13,627,12,629,7,629,11,631,13 DATA 632,13,631,13 DATA -1,-1 ' ---------------------------------------------------------------------------- RETURN ' ############################################################################## ' D o k u m e n t a t i o n : ' ############################################################################## > PROCEDURE 0_konzept_fuer_das_aussehen_einer_einzelnen_note ' ---------------------------------------------------------------------------- ' Muster einer Note mit Notenhals nach unten: ' ---------------------------------------------------------------------------- ' ' ' ' ' 1 ' 0123456789012345 = n_nb| Notenbsp.: oberes cis (ex. nicht, nur bis c): ' Das cis ist mit der vorherigen Note gebunden, ' betont,erhöht (nicht erhöht wäre es c) & 1/32 lang. ' ' ' ############# <-- Obereste Begrenzungslinie ' 0 1 <-- 1. Punkt im Notenrechteck=g_y%(?) ' 1 2 ' 2 3 ' 3 4 ' 4 5 ' 5 ++6+1 ' 6 1 ' 7 2 ' 8 3 ' 9 4 ' 10 5 ###### ' 1 ++6+2 # # <-- Gebunden mit vorheriger Note ( Box: gd|,gh|,gx|,gy| ) ' 2 1 ###### ' 3 2 ' 4 3 ' 5 4 ###### <-- Notenkopf ( Pbox: kb|, kh|, kx|, ky| ) ' 6 5 ###### ' 7 ++6+3######### <-- Hilfslinie a2 (line: ha2x|, ha2y|, hd| ) ' 8 1 ###### ' 9 2 ###### ' 20 3 ######### <-- Hilfslinie h2 (line: hh2x|, hh2y|, hd| ) ' 1 4 # ' 2 5 #### <-- Betonungszeichen ( Pbox: bb|, bh|, bx|, by| ) ' 3 ++6+4######### <-- Hilfslinie c3 (line: hc3x|, hc3y|, hd| ) ' 4 1 #### ' 5 2 # <-- Notenhals ( Line: lx|, lsy|, ley| ' 6 3 ###### ' 7 4 ## ## <-- Notenhöhen-Info: Kreuz ( 1.Box: xl|,hb|, hh|, hy| ' 8 5 ## ## 2.Box: xr|, " " " ) ' 9 ++6+5 ## ## <-- 1.Notenlinie ( n1y| bei: '1_notenlinien' ' 30 1 ###### ' 1 2 # ' 2 3 # ## ' 3 4 # ## <-- 32-tel-Fähnchen ( Line: ax1|,a32y1|,ax2|,a32y2| ) ' 4 5 # ## <-- 32-tel-Fähnchen ( Line: ax1|,b32y1|,bx2|,a32y2| ) ' 5 ++6+6 ### ' 6 1 ## ## ' 7 2 # ## <-- 16-tel-Fähnchen ( Line: ax1|,a16y1|,ax2|,a16y2 ) ' 8 3 # ## <-- 16-tel-Fähnchen ( Line: ax1|,b16y1|,bx2|,a16y2 ) ' 9 4 ### ' 40 5 ## ## ' 1 ++6+7 # ## <-- 8-tel-Fähnchen ( Line ax1|,a8y1|,ax2|,a8y2 ) ' 2 1 # ## <-- 8-tel-Fähnchen ( Line ax1|,b8y1|,bx2|,a8y2 ) ' 3 2 ### ' 4 3 ## ' 5 4 ' 6 5 ' 7 ++6+8 # ' 8 1 # ' 9 2 # ' 50 3 # <-- Notenhals vom c1 ' 1 4 # ' 2 5 # ' 3 ++6+9 # ' 4 1 # ' 5 2 # ' 6 3 # ' 7 4 ###### ' 8 5 ###### ' 9 ++6+1######### <-- Hilfslinie c1 (line: hc1x|, hc1y|, hd| ) . ' 60 1 ###### ' 1 2 ###### ' 2 3 ' 3 4 <-- falscher Anfang vom gespiegelten Gebundenzei- ' 4 5 ###### chen bei '3_gebundenzeichen()'. (*):s.Zeile 66. ' 5 ++6+11# # ' 6 1 ###### <-- richtiger Anfang für Gebundenzeichen vom c1. Diff. v. ' 7 2 falschen Anfang bei (*) wird bei '2_noten_foto()' ge- ' 8 3 braucht: ( rga%=-3 ): ' 9 4 ' 70 5 ' 1 ++6+12 ' 2 ################# <-- unterste Begrenzungslinie ' 3 <-- 1.Pkt d.benachbarten,unt.Notenbereichs=g_y%(?')=g_y%(?)+g_nzlh| ' g_nzlh|=73 ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_konzept_fuer_die_notendarstellung_im_edr ' ---------------------------------------------------------------------------- ' 0.) Der Bildschirm wird unterhalb der Klaviatur in 5 Notenzeilen und 80 ' Notenspalten aufgebaut. Das Konzept der Notendarstellung soll nun so ' aussehen, daß man nur noch die gewünschte Notenposition, also eine ' dieser Notenspalten bzw. -zeilen angeben muß und die gewünschten Eigen- ' schaften, wie Höhe, Länge, usw. ' 1.) Alle möglichen Notenformen werden gezeichnet und fotografiert, d.h. ' im Array 'g_nb$()' als einzelne Bilder abgespeichert. Die Argumente ' dieses Arrays entsprechen den Eigenschaften der entsprechenden Note: ' Im 1. Argument steht die Notenhöhe, im 2. die Länge dh. die Fähnchenzahl ' im 3. ob gebunden (=1) oder nicht(=0) im 4. ob betont oder nicht. ' 2.) Die 'Fotokamera' wird so plaziert, daß später nur noch Spalte und Zeile ' einer Note als Argumente für den Put-Befehl zum Projezieren der Photos ' angegeben werden müssen. ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_konzept_zur_speicherung_der_noten ' ---------------------------------------------------------------------------- ' 1.) Wenn man das Programm startet und erst einmal ein neues Notenstück ' schreibt, werden dessen Noten zunächst nur im 'g_n$()'-Array abgelegt. ' 2.) Speichert man dieses Notenstück nun ab, so wird es nicht als einzelnes ' File auf Diskette geschrieben, sondern in das sogenannte 'Hauptfile' ' eingebaut. In diesem Hauptfile haben 160 Notenstücke zu je 200 Noten ' Platz. Beim Speichern und Laden, kann man nun aus diesen 160 Stücken ' eins auswählen, das überschrieben bzw. in den g_n$()-Array zur aktuellen ' Bearbeitung geladen werden soll. Dabei sind Stücke mit dem Namen ' '________' leer. ' Gibt man beim Abspeichern den Leerstring '________' ' ein, so wird das entsprechende Stück im Hauptfile gelöscht. ' 3.) Man kann dieses Hauptfile über die Prozedur 'ende_file_drck' auf eine ' andere Diskette kopieren, bzw. ein neues auf einer Diskette anlegen, ' auf welcher sich noch kein Hauptfile befindet. ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_zeichenprogramm ' ---------------------------------------------------------------------------- ' Mit diesem Kleinen Programm wurde der Notenschlüssel für die Druckfunktion ' gezeichnet. Dafür muß es an den Programmanfang, genau hinter der Zeile ' '@0_programmbild_malen' verschoben werden. Verwende dazu die Zeile: ' @0_zeichnenprogramm ' Die durch die linke Maustaste ' markierten Punkte werden dann in Form von Datazeilen auf Diskette ge- ' speichert und können durch die Funktion 'Merge' vom Editor aus in den ' Programmtext aufgenommen werden. ' Die Prozedur, die die in den Programmtext bereits aufgenommenen Data- ' zeilen verwertet, d.h.`das Bild reproduziert, hat in 'NOTEDITA' den ' Namen '1_notenschluessel'. ' ............................................................................ LOCAL m| ! Maustaste LOCAL r| ! Menüauswahl LOCAL a% ! Höchstanzahl aller Punkte LOCAL i% ! Punkt-/Zeilen-zähler LOCAL j% ! Spaltenzähler ' ............................................................................ ' ! Alles ab hier muß hinter '@0_progra.' nochmal_zeichnen: ! Label ' SPUT g_lb$ ! Löschbild ' ! Bilderrahmen: BOX g_x%(51),g_y%(51),g_x%(51)+2*g_nb|-1,g_y%(51)+g_nzlh|-2 LET a%=100 ! Höchstens hundert Punkte (auch mehr möglich) DIM x%(a%),y%(a%) ! Koordinatenarray dimensionieren LET x%(0)=g_x%(51) ! x-Startwert festlegen LET y%(0)=g_y%(51) ! y-Startwert festlegen REPEAT ! Hauptzeichenschleife REPEAT ! Schleife, um Mauspuffer UNTIL MOUSEK=0 ! zu leeren REPEAT ! Warten auf LET m|=MOUSEK ! Mausklick UNTIL m| ! d PRINT AT(1,1);"i%='";i%;"'" ! d INC i% ! Punktzähler um eins erhöhen LET x%(i%)=MOUSEX ! x-Koordinate vom akt. Pkt. festlegen LET y%(i%)=MOUSEY ! y-Koordinate vom akt. Pkt. festlegen IF i%>1 ! f schon ein Punkt da: LINE x%(i%-1),y%(i%-1),x%(i%),y%(i%) ! Linie vom alten zum akt Punkt ENDIF ! d UNTIL m|=2 ! Raus ausZeichenschleife,falls rechte Maustaste ' ............................................................................ @a_alert("Nochmal zeichnen?/Ja|Abspeichern",r|) ! d IF r|=1 ! f ja gewählt: CLS ! Bildschirm löschen LET i%=0 ! Punktzähler null ERASE x%(),y%() ! Punktkoordinatenarrays löschen GOTO nochmal_zeichnen ! von neuem Zeichnen ENDIF ! d LET a%=i% ! Höchstanzahl der Punkte neu setzen ' ............................................................................ OPEN "O",#1,"NOTENS.LST" ! File auf Diskette zum schreiben öffnen FOR i%=1 TO a% ! alle Punkte durch IF FRAC(j%/5)=0 ! f neuer Zeilenanfang ansteht: LET j%=1 ! Spaltenzähler initialisieren PRINT #1, ! neue Zeile PRINT #1,"DATA "; ! 'DATA' an den Anfang der neuen Zeile ELSE ! f mitten in Zeile INC j% ! nur Spaltenzähler um eins erhöhen ENDIF ! d IF i%<a% AND j%<5 ! f noch nicht zu Ende und in Zeilenmitte: PRINT #1,x%(i%);",";y%(i%);","; ! Koordinaten raus, mit Komma am Schluß ELSE ! f am Ende oder am Zeilenende PRINT #1,x%(i%);",";y%(i%); ! Koordinaten raus, ohne Komma am Schluß ENDIF ! d NEXT i% ! nächster Punkt PRINT #1 ! neue Zeile PRINT #1,"DATA -1,-1" ! Schlußdaten CLOSE #1 ! File auf Diskette schließen ' ............................................................................ EDIT ! Zurück in den Editor ' ---------------------------------------------------------------------------- RETURN > PROCEDURE 0_ausfuehrliche_befehlsdokumentation_fuer_noteneingabe ' ---------------------------------------------------------------------------- ' Achtung! Erst Zeilen-, dann Spaltennummer ! ! ! ' ' ' 1.Spalte: 2.Spalte: 3.Spalte: 4.Spalte: 5.Spalte: ' ' | linksoben | Notentaste | rechtsoben | Notentext | Cursor | ' ' |--------------------------------------------------------------| ' 1 LMT | Pause | 1/8 Note | Pause | Cursorpos. | Taktstr. | ' |------------+------------+------------+------------+----------| ' 2 RMT | Hauptmenü | Nur Ton | Backspace | Abspielen | Fähnchen | ' |--------------------------------------------------------------| ' ' ' ---------------------------------------------------------------------------- ' ' ' Jetzt die 1. Zeile ' ' ' ---------------------------------------------------------------------------- ' ' ' ' * S p a l t e 1 : 'l. Pausentaste' Zeile1: 'LMT' ' (linke Pausentaste auf Klaviatur und linke Maustaste) ' 'Pause': Funktioniert, wenn kein Blockbereich definiert ist: ' Es wird eine 1/8-tel-Pause dargestellt ' Kann auch mit der Space-Taste produziert werden. ' PROCEDURE 1_write(t|,x%) !_: ' ............................................................................ ' * S p a l t e 2 : 'Notentaste' Zeile1: 'LMT' ' (Notentaste auf Klaviatur und linke Maustaste) ' PROCEDURE 1_write(t|,x%) !_: ' '1/8-Note': Eine der Klaviaturtaste entspr. 1/8-Note wird dargestellt. ' Es handelt sich um einen normalen Halbton. ' Bei MIDI muß noch die 'Alternate'-Taste dazu gedrückt wer- ' den. ' ............................................................................ ' * S p a l t e 3 : 'r. Pausentaste' Zeile1: 'LMT' ' (rechte Pausentaste auf Klaviatur und linke Maustaste) ' 'Pause': Funktioniert, wenn kein Blockbereich definiert ist: ' Es wird eine 1/8-tel-Pause dargestellt ' Kann auch mit der Space-Taste produziert werden. ' PROCEDURE 1_write(t|,x%) !_: ' ............................................................................ ' * S p a l t e 4 : 'Notentext' Zeile1: 'LMT' ' (Mauspfeil auf Notentext und linke Maustaste) ' PROCEDURE 1_neu_cpos(x%,y%) !_: ' Falls Cursor nicht auf Note unter Mauspfeil: ' 'Cursorpos.': Der Cusor wird auf die Note unter dem Mauspfeil gesetzt. ' ............................................................................ ' * S p a l t e 5 : 'Cursor' Zeile1: 'LMT' ' PROCEDURE 2_takt_setzen !_: ' Falls Cursor auf Note unter Mauspfeil: ' 'Taktstr.': Hier gesellt sich zur Note ein Taktstrich, falls vorher ' noch keiner da war. War bereits einer da, so wird er ge- ' löscht. ' ' ' ---------------------------------------------------------------------------- ' ' ' Jetzt die 2. Zeile ' ' ' ---------------------------------------------------------------------------- ' ' ' ............................................................................ ' * S p a l t e 1 : 'l. Pausentaste' Zeile2: 'RMT' ' (linke Pausentaste auf Klaviatur und rechte Maustaste) ' PROCEDURE 0_hauptmenue !_: ' 'Hauptmenü': Hier kommt man ins Hauptmenü ' Kann auch mit der 'Esc'-Taste erreicht werden. ' ............................................................................ ' * S p a l t e 2 : 'Notentaste' Zeile2: 'RMT' ' (Notentaste auf Klaviatur und rechte Maustaste) ' PROCEDURE 1_nur_ton(x%) !_: ' 'Nur Ton': Man hört nur eine Note, die wird aber weder dargestellt noch ' gespeichert. ' ............................................................................ ' * S p a l t e 3 : 'r. Pausentaste' Zeile2: 'RMT' ' (rechte Pausentaste auf Klaviatur und rechte Maustaste) ' PROCEDURE 1_backspace !_: ' 'Backspace': Die Note links vom Cursor wird gelöscht. ' Kann auch mit der linken Space-Taste erreicht werden. ' ............................................................................ ' * S p a l t e 4 : 'Notentext' Zeile2: 'RMT' ' (Mauspfeil auf Notentext und rechte Maustaste) ' PROCEDURE 1_spielen(x%,y%) !_: ' 'Abspielen': Alle Noten zwischen und einschließlich den Noten unter dem ' Cursor & unter dem Mauspfeil werden nacheinander gespielt. ' * Abbruch bei Abspielen: Auf die linke Maustaste drücken. ' Wenn Noten vom Programm abgespielt werden, kann dies mit der linken ' Maustaste abgebrochen werden. ' ............................................................................ ' * S p a l t e 5 : 'Cursor' Zeile2: 'RMT' ' PROCEDURE 1_faehnchen !_: ' 'Fähnchen': Bei der Note unter dem Cursor kommt noch ein Fähnchen dazu. ' Geht das nicht mehr, so fängt's wieder bei 0 Fähnchen an. ' ............................................................................ ' ' ............................................................................ ' ' ' B e f e h l e, n u r ü b e r T a s t e n e r r e i c h b a r : ' ' ' 'Control'-Taste: Cursor eins weiter nach links ' (Ein entsprechender Mausklick wird simuliert) ' ' 'Tab'-Taste: Cursor eins weiter nach rechts ' (Ein entsprechender Mausklick wird simuliert) ' ' 'Help'-Taste: Hilfstext mit Befehlsübersicht und allerlei Infos ' ' 'a'oder'A': Stück von anfang an durchspielen ' ............................................................................ RETURN > PROCEDURE 0_ausfuehrliche_befehlsdukumentation_fuer_hauptmenue ' ' ---------------------------------------------------------------------------- ' ' ' ' H a u p t m e n ü b e f e h l e : ' ' ' ---------------------------------------------------------------------------- ' Die Unterteilung des Hauptmenüs: ' Stückmenü ' Hauptfile ' Blockmenü ' Parameter ' Menü-Exit ' ' ---------------------------------------------------------------------------- ' stueckmenue: ' ---------------------------------------------------------------------------- ' M e n ü p u n k t : Stück auf Disk speichern ' PROCEDURE 2_stueck_abspeichern !_: ' * Aktuelles Stück im RAM wird als einzelnes File vom RAM auf Diskette ' abgespeichert. ' M e n ü p u n k t : Stück von Disk laden ' PROCEDURE 2_stueck_laden !_: ' * Ein einzeln auf Diskette abgespeichertes Stück wird geladen und an die ' Stelle des aktuellen Stücks im RAM gesetzt. Das alte (vorher aktuelle) ' Stück geht dabei verloren (UNDO möglich). ' M e n ü p u n k t : Stück in Hauptfile speichern ' PROCEDURE 1_abspeichern !_: ' * Der Notentext wird abgespeichert. Wird hierbei als ' * Speichername "________" eingegeben, so wird das Stück, ' dessen Name damit überschrieben wurde, gelöscht. ' Abbruch durch Eingabe von '-1' möglich. ' M e n ü p u n k t : Stück von Hauptfile laden ' PROCEDURE 1_laden !_: ' * Der Notentext wird geladen. ' U n d o - Möglichkeit ! ' M e n ü p u n k t : bestimmte Stücke drucken ' PROCEDURE 2_drucken_gewaehlte !_: ' * Einzelne, gewählte Stücke drucken. ' Abbruch vor jeder Druckseite einzeln od. insgesamt durch Alertbox möglich. ' M e n ü p u n k t : bestimmte Stücke spielen ' PROCEDURE 2_spielen_gewaehlte !_: ' * Einzelne, gewählte Stücke spielen. ' Abbruch während des Spielens durch 'Esc'-Taste. ' ---------------------------------------------------------------------------- ' hauptfile: ' ---------------------------------------------------------------------------- ' M e n ü p u n k t : Hauptfile neuanlegen ' PROCEDURE 2_hauptfileneuanlegen !_: ' * Hauptfile auf Diskette und im RAM neuanlegen. ' M e n ü p u n k t : Hauptfile neu laden ' PROCEDURE 2_hauptfile_laden !_: ' * Haupfile von Diskette ins RAM laden. ' M e n ü p u n k t : Hauptfile abspeichern ' PROCEDURE 2_save_hauptfile !_: ' * Hauptfile vom RAM auf Diskette abspeichern. ' M e n ü p u n k t : beliebiges File löschen ' PROCEDURE 2_file_loeschen !_: ' * File auf Diskette löschen. Muß bestätigt werden. ' M e n ü p u n k t : File umbenennen ' PROCEDURE 2_rename_file !_: ' * Name eines Files kann hier geändert werden. ' M e n ü p u n k t : Inhaltsverzeichnis drucken ' PROCEDURE 2_inhverz_drucken !_: ' * Inhaltsverzeichnis des Hauptfiles drucken. ' M e n ü p u n k t : Alle Stücke drucken ' PROCEDURE 2_drucken_ab_x_alle !_: ' * Ab einer wählbaren Stelle im alphabetisch geordneten Inhaltsverzeichnis ' alle restlichen Stücke drucken. Abbruch durch Eingabe von '-1'. ' Abbruch vor jeder Druckseite einzeln od. insgesamt durch Alertbox möglich. ' M e n ü p u n k t : Alle Stücke spielen ' PROCEDURE 2_spielen_ab_x_alle !_: ' * Ab einer wählbaren Stelle im alphabetisch geordneten Inhaltsverzeichnis ' alle restlichen Stücke spielen. Abbruch durch Eingabe von '-1'. ' Abbruch während des Spielens durch 'Esc'-Taste. ' ---------------------------------------------------------------------------- ' blockmenue: ' ---------------------------------------------------------------------------- ' M e n ü p u n k t : Anfang ' PROCEDURE 1_blockmark(x%,y%) !_: ' * Blockanfang wird gesetzt und damit das Blockende auf Text- ' Ende. Ist Blockanfang schon gesetzt worden, ' dann halt Blockende,wenn Blockende auf Blockanfang gesetzt, ' dann wird die Blockmarkierung rückgängig gemacht=gelöscht. ' M e n ü p u n k t : Ende ' PROCEDURE 1_blockmark(x%,y%) !_: ' * Blockanfang wird gesetzt und damit das Blockende auf Text- ' ende. ' M e n ü p u n k t : kopieren ' PROCEDURE 1_block_kopieren !_: ' * Der Block wird vor den Cursor kopiert ' M e n ü p u n k t : doppelt so schnell ' PROCEDURE 3_bl_faehnchen(v!,x%) !_: ' * Funktioniert, wenn Blockbereich definiert ist: ' Es wird überall im Block ein Fähnchen dazugesetzt. ' M e n ü p u n k t : halb so schnell ' PROCEDURE 3_bl_faehnchen(v!,x%) !_: ' * Funktioniert, wenn Blockbereich definiert ist: ' Es wird überall im Block ein Fähnchen weniger dargestellt. ' M e n ü p u n k t : transponieren ' PROCEDURE 3_bl_transponieren(x%)!_: ' * Block transponieren: gewünschte Startnote auf Klaviatur anklicken ' Wenn bereits ein Block über Blockmarken definiert worden ist, kann der ' gesamte Blockbereich um eine gewünschte Differenz in der Tonhöhe ver- ' schoben werden. Die Differenz errechnet sich dabei folgendermaßen. ' Ausgegangen wird von der 1. Note im Blockbereich. Dann klickt man die ' gewünschte neue Startnote auf der Klaviatur an. Die Differenz dieser ' beiden Töne ist dann die Verschiebedifferenz der Transponierprozedur. ' M e n ü p u n k t : löschen ' PROCEDURE 2_block_loeschen !_: ' * Der Block wird gelöscht. Bestätigung erforderlich. ' U n d o - Möglichkeit ! ' ---------------------------------------------------------------------------- ' parameter: ' ---------------------------------------------------------------------------- ' M e n ü p u n k t : Abspielgeschwindigkeit ' PROCEDURE 1_abspielgeschw !_: ' * Die Abspielgeschwindigkeit kann verändert werden. ' M e n ü p u n k t : Pause zw den Stücken ' PROCEDURE 1_stueckpause !_: ' * Pause zwischen den Stücken beim Abspielen mehrerer Stücke kann hier ein- ' gestellt werden ' M e n ü p u n k t : Tonhöhe ' PROCEDURE 1_tonhoehe !_: ' * Die Tonhöhe kann verändert werden, nur für einen kleinen Bereich um ' 440 Hz sinnvoll, da sonst Unstimmigkeiten auftreten. ' M e n ü p u n k t : Midi ein/aus ' PROCEDURE 1_midi_ein_aus !_: ' * Hier wird festgelegt, wo die Tonausgabe stattfinden soll und ob ein ' Keyboard zur Eingabe verwendbar ist. ' ---------------------------------------------------------------------------- ' menue_exit: ' ---------------------------------------------------------------------------- ' M e n ü p u n k t : Eingabe fortsetzen ' * hier wird nichts gemacht ' M e n ü p u n k t : Edit ' PROCEDURE 1_programmende(w|) !_: ' * in den Editor ohne Bestätigung ' M e n ü p u n k t : Quit ' PROCEDURE 1_programmende(w|) !_: ' * Das Programm beenden, Bestätigung erforderlich. ' ---------------------------------------------------------------------------- ' ' !! w i c h t i g !! ' ' ---------------------------------------------------------------------------- ' Ein Menü, in dem die aktuellen Einträge invers dargestellt werden, kann ' durch die linke Maustaste und Mauspfeil außerhalb der Einträge abge- ' brochen werden. ' Muß in einem Menü etwas eingegeben werden, so kann auch hier abgebrochen ' werden, nämlich indem man einfach nichts eingibt. ' ---------------------------------------------------------------------------- RETURN ' ############################################################################## ' P r o g r a m m t e x t e n d e : ' ##############################################################################